@geotechcli/core 0.4.105 → 0.4.107

package/dist/fem/validation.js

@@ -19,6 +19,20 @@ function isNonEmptyString(value) {
 }
 const FEM_WEBGL_UINT16_INDEX_LIMIT = 65_535;
 const FEM_MAX_PREVIEW_MESH_NODES = FEM_WEBGL_UINT16_INDEX_LIMIT + 1;
+const FEM_MIN_BIOT_TRANSIENT_STEPS = 3;
+const FEM_MAX_BIOT_TIME_STEP_GROWTH_RATIO = 8;
+function expectedMeshCounts(mesh) {
+    if (mesh.elementType === 'quad4_plane_strain') {
+        return {
+            nodes: (mesh.divisionsX + 1) * (mesh.divisionsY + 1),
+            elements: mesh.divisionsX * mesh.divisionsY,
+        };
+    }
+    return {
+        nodes: (mesh.divisionsX + 1) * (mesh.divisionsY + 1) * (mesh.divisionsZ + 1),
+        elements: mesh.divisionsX * mesh.divisionsY * mesh.divisionsZ,
+    };
+}
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }
@@ -53,7 +67,7 @@ function isFemAnalysisCaseShape(value) {
     const groundwater = value.groundwater;
     return (isRecord(geometry) &&
         isRecord(geometry.domain) &&
-        (isRecord(geometry.raft) || isRecord(geometry.excavation) || isRecord(geometry.tunnel) || isRecord(geometry.consolidation)) &&
+        (isRecord(geometry.raft) || isRecord(geometry.excavation) || isRecord(geometry.tunnel) || isRecord(geometry.consolidation) || isRecord(geometry.biot)) &&
         isRecord(mesh) &&
         isRecord(groundwater) &&
         isRecord(value.units) &&
@@ -173,7 +187,7 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
     const validFieldLocations = new Set(['surface_nodes', 'outline_nodes', 'envelope']);
     const validFieldQuantities = new Set(['displacement', 'reaction', 'load', 'stage_count', 'pore_pressure', 'degree_of_consolidation', 'strength_ratio']);
     const validFieldComponents = new Set(['x', 'y', 'z', 'magnitude']);
-    const validDatasetSources = new Set(['visualization.disp', 'visualization.frame', 'envelope']);
+    const validDatasetSources = new Set(['visualization.disp', 'visualization.frame', 'visualization.scalar-frame', 'envelope']);
     const fieldIds = new Set();
     const stepIds = new Set();
     const stepIndexes = new Set();
@@ -209,6 +223,21 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
         ['max_mobilized_strength_ratio', manifest.envelope.maxMobilizedStrengthRatio],
         ['drainage_path', manifest.envelope.drainagePathM],
         ['consolidation_duration', manifest.envelope.consolidationDurationYears],
+        ['time_step_count', manifest.envelope.timeStepCount],
+        ['min_pore_pressure', manifest.envelope.minPorePressureKpa],
+        ['max_pore_pressure', manifest.envelope.maxPorePressureKpa],
+        ['max_biot_coupling', manifest.envelope.maxBiotCouplingKpa],
+        ['pore_pressure_mass_balance_error_ratio', manifest.envelope.porePressureMassBalanceErrorRatio],
+        ['max_free_pore_pressure_residual', manifest.envelope.maxFreePorePressureResidualM3PerS],
+        ['free_pore_pressure_residual_l1', manifest.envelope.freePorePressureResidualL1M3PerS],
+        ['prescribed_pore_pressure_residual_l1', manifest.envelope.prescribedPorePressureResidualL1M3PerS],
+        ['average_pore_pressure', manifest.envelope.averagePorePressureKpa],
+        ['average_free_pore_pressure', manifest.envelope.averageFreePorePressureKpa],
+        ['pore_pressure_dissipation_ratio', manifest.envelope.porePressureDissipationRatio],
+        ['max_pore_pressure_change_rate', manifest.envelope.maxPorePressureChangeRateKpaPerS],
+        ['coupled_unknown_count', manifest.envelope.coupledUnknownCount],
+        ['displacement_dof_count', manifest.envelope.displacementDofCount],
+        ['pore_pressure_dof_count', manifest.envelope.porePressureDofCount],
         ['tunnel_diameter', manifest.envelope.tunnelDiameterM],
         ['tunnel_axis_depth', manifest.envelope.tunnelAxisDepthM],
         ['volume_loss', manifest.envelope.volumeLossPercent],
@@ -235,8 +264,11 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
             if (fieldInfo.component != null && !validFieldComponents.has(String(fieldInfo.component))) {
                 findings.push(finding('blocker', `result.fields.${index}.component.invalid`, `Unsupported result field component: ${String(fieldInfo.component)}.`));
             }
-            if (fieldInfo.location !== 'envelope' && fieldInfo.quantity !== 'displacement') {
-                findings.push(finding('blocker', `result.fields.${index}.node-quantity-invalid`, 'Surface and outline node result fields must describe displacement quantities.'));
+            if (fieldInfo.location !== 'envelope' && fieldInfo.quantity !== 'displacement' && fieldInfo.quantity !== 'pore_pressure') {
+                findings.push(finding('blocker', `result.fields.${index}.node-quantity-invalid`, 'Surface and outline node result fields must describe displacement or pore-pressure quantities.'));
+            }
+            if (fieldInfo.location === 'outline_nodes' && fieldInfo.quantity === 'pore_pressure') {
+                findings.push(finding('blocker', `result.fields.${index}.outline-pore-pressure-invalid`, 'Pore-pressure result fields must be surface-node scalar fields.'));
             }
             if (fieldInfo.location !== 'envelope' && fieldInfo.quantity === 'displacement' && fieldInfo.component == null) {
                 findings.push(finding('blocker', `result.fields.${index}.component.missing`, 'Node displacement result fields must include a displacement component.'));
@@ -271,6 +303,7 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
             }
         }
     }
+    let previousTimeSeconds;
     if (Array.isArray(steps)) {
         for (const [index, step] of steps.entries()) {
             const id = pushUniqueStringFinding(findings, stepIds, step.id, `result.steps.${index}.id`, 'Result step id');
@@ -294,6 +327,26 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
             if (step.depthM != null && (!Number.isFinite(step.depthM) || step.depthM < 0)) {
                 findings.push(finding('blocker', `result.steps.${index}.depth-invalid`, 'Result step depth must be finite and non-negative when present.'));
             }
+            if (step.timeSeconds != null && (!Number.isFinite(step.timeSeconds) || step.timeSeconds < 0)) {
+                findings.push(finding('blocker', `result.steps.${index}.time-invalid`, 'Result step timeSeconds must be finite and non-negative when present.'));
+            }
+            if (step.deltaTimeSeconds != null && (!Number.isFinite(step.deltaTimeSeconds) || step.deltaTimeSeconds <= 0)) {
+                findings.push(finding('blocker', `result.steps.${index}.delta-time-invalid`, 'Result step deltaTimeSeconds must be finite and positive when present.'));
+            }
+            if (manifest.analysisCase.objective === 'seepage_groundwater_coupling') {
+                if (!isFiniteNumber(step.timeSeconds) || step.timeSeconds <= 0) {
+                    findings.push(finding('blocker', `result.steps.${index}.time-required`, 'Biot consolidation result steps must carry a positive timeSeconds value.'));
+                }
+                if (!isFiniteNumber(step.deltaTimeSeconds) || step.deltaTimeSeconds <= 0) {
+                    findings.push(finding('blocker', `result.steps.${index}.delta-time-required`, 'Biot consolidation result steps must carry a positive deltaTimeSeconds value.'));
+                }
+            }
+            if (isFiniteNumber(step.timeSeconds)) {
+                if (previousTimeSeconds != null && step.timeSeconds <= previousTimeSeconds) {
+                    findings.push(finding('blocker', `result.steps.${index}.time-order-invalid`, 'Result step timeSeconds values must increase monotonically.'));
+                }
+                previousTimeSeconds = step.timeSeconds;
+            }
             if (manifest.analysisCase.objective === 'excavation_deformation') {
                 if (!step.analysisStageId) {
                     findings.push(finding('blocker', `result.steps.${index}.stage-required`, 'Excavation result steps must reference an analysis stage.'));
@@ -367,15 +420,31 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
                 findings.push(finding('blocker', `result.datasets.${index}.source.invalid`, `Unsupported result dataset source: ${String(dataset.source)}.`));
             }
             const location = fieldLocations.get(dataset.fieldId);
-            if ((dataset.source === 'visualization.disp' || dataset.source === 'visualization.frame') && dataset.stepId == null) {
+            const fieldInfo = fieldInfoById.get(dataset.fieldId);
+            const isVisualizationDataset = dataset.source === 'visualization.disp' ||
+                dataset.source === 'visualization.frame' ||
+                dataset.source === 'visualization.scalar-frame';
+            if (isVisualizationDataset && dataset.stepId == null) {
                 findings.push(finding('blocker', `result.datasets.${index}.step-required`, 'Visualization datasets must reference a result step.'));
             }
-            if ((dataset.source === 'visualization.disp' || dataset.source === 'visualization.frame') && location === 'envelope') {
+            if (isVisualizationDataset && location === 'envelope') {
                 findings.push(finding('blocker', `result.datasets.${index}.visualization-field-invalid`, 'Visualization datasets must reference surface or outline node result fields, not envelope fields.'));
             }
             if (dataset.source === 'envelope' && location !== 'envelope') {
                 findings.push(finding('blocker', `result.datasets.${index}.envelope-field-invalid`, 'Envelope datasets must reference an envelope result field.'));
             }
+            if ((dataset.source === 'visualization.disp' || dataset.source === 'visualization.frame') && dataset.stride !== 3) {
+                findings.push(finding('blocker', `result.datasets.${index}.visualization-stride-invalid`, 'Displacement visualization datasets must use stride 3.'));
+            }
+            if ((dataset.source === 'visualization.disp' || dataset.source === 'visualization.frame') && fieldInfo?.quantity !== 'displacement') {
+                findings.push(finding('blocker', `result.datasets.${index}.visualization-quantity-invalid`, 'Displacement visualization datasets must reference displacement result fields.'));
+            }
+            if (dataset.source === 'visualization.scalar-frame' && dataset.stride !== 1) {
+                findings.push(finding('blocker', `result.datasets.${index}.scalar-stride-invalid`, 'Scalar-frame visualization datasets must use stride 1.'));
+            }
+            if (dataset.source === 'visualization.scalar-frame' && fieldInfo?.quantity !== 'pore_pressure') {
+                findings.push(finding('blocker', `result.datasets.${index}.scalar-quantity-invalid`, 'Scalar-frame visualization datasets must reference pore-pressure result fields.'));
+            }
             if (dataset.source === 'visualization.disp' && !arraysApproximatelyEqual(dataset.values, manifest.visualization.disp, 1e-12)) {
                 findings.push(finding('blocker', `result.datasets.${index}.disp-values-mismatch`, 'Visualization displacement dataset values must match the manifest visualization displacement array.'));
             }
@@ -388,6 +457,18 @@ function validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNo
                     findings.push(finding('blocker', `result.datasets.${index}.frame-values-mismatch`, 'Visualization frame dataset values must match the referenced frame displacement array.'));
                 }
             }
+            if (dataset.source === 'visualization.scalar-frame' && dataset.stepId != null) {
+                const frame = frameByKey.get(`${dataset.fieldId}:${dataset.stepId}`);
+                if (!frame) {
+                    findings.push(finding('blocker', `result.datasets.${index}.scalar-frame-missing`, 'Scalar-frame dataset has no matching frame payload.'));
+                }
+                else if (!Array.isArray(frame.scalarValues)) {
+                    findings.push(finding('blocker', `result.datasets.${index}.scalar-frame-values-missing`, 'Scalar-frame dataset must reference a frame with scalarValues.'));
+                }
+                else if (!arraysApproximatelyEqual(dataset.values, frame.scalarValues, 1e-12)) {
+                    findings.push(finding('blocker', `result.datasets.${index}.scalar-frame-values-mismatch`, 'Scalar-frame dataset values must match the referenced frame scalarValues array.'));
+                }
+            }
             const valueCount = dataset.values.length / dataset.stride;
             if (location === 'surface_nodes' && valueCount !== nodeCount) {
                 findings.push(finding('blocker', `result.datasets.${index}.surface-count-mismatch`, 'Surface-node dataset values must match visualization base node count.'));
@@ -480,7 +561,7 @@ export function validateFemAnalysisCase(caseFile) {
             finding('blocker', 'schema.shape-invalid', 'FEM analysis case is missing required geometry, mesh, groundwater, or array fields.'),
         ]);
     }
-    const { domain, raft, excavation, tunnel, consolidation } = caseFile.geometry;
+    const { domain, raft, excavation, tunnel, consolidation, biot } = caseFile.geometry;
     if (caseFile.schemaVersion !== 'fem-analysis-case.v0') {
         findings.push(finding('blocker', 'schema.unsupported', 'Only fem-analysis-case.v0 is supported.'));
     }
@@ -499,7 +580,7 @@ export function validateFemAnalysisCase(caseFile) {
     if (!caseFile.experimental) {
         findings.push(finding('blocker', 'mode.experimental-required', 'FEM cases must be explicitly marked experimental.'));
     }
-    if (!['foundation_settlement', 'excavation_deformation', 'tunnel_volume_loss_settlement', 'staged_settlement_consolidation'].includes(caseFile.objective)) {
+    if (!['foundation_settlement', 'excavation_deformation', 'tunnel_volume_loss_settlement', 'staged_settlement_consolidation', 'seepage_groundwater_coupling'].includes(caseFile.objective)) {
         findings.push(finding('blocker', 'objective.unsupported', `Unsupported FEM objective: ${caseFile.objective}.`));
     }
     if (caseFile.objective === 'foundation_settlement' && caseFile.analysisType !== 'static_3d_small_strain') {
@@ -514,6 +595,9 @@ export function validateFemAnalysisCase(caseFile) {
     if (caseFile.objective === 'staged_settlement_consolidation' && caseFile.analysisType !== 'time_dependent_1d_consolidation') {
         findings.push(finding('blocker', 'analysis.unsupported', `Unsupported analysis type: ${caseFile.analysisType}.`));
     }
+    if (caseFile.objective === 'seepage_groundwater_coupling' && caseFile.analysisType !== 'time_dependent_2d_biot_consolidation') {
+        findings.push(finding('blocker', 'analysis.unsupported', `Unsupported analysis type: ${caseFile.analysisType}.`));
+    }
     if (caseFile.geometry.domain.type !== 'box') {
         findings.push(finding('blocker', 'geometry.domain.type-invalid', `Unsupported domain type: ${String(caseFile.geometry.domain.type)}.`));
     }
@@ -691,6 +775,75 @@ export function validateFemAnalysisCase(caseFile) {
             findings.push(finding('review', 'consolidation.1d-preview', 'Staged consolidation preview uses a 1D Terzaghi column and Mohr-Coulomb material-point review gate; it is not a full 2D/3D coupled FEM consolidation solver.'));
         }
     }
+    if (caseFile.objective === 'seepage_groundwater_coupling') {
+        if (!biot) {
+            findings.push(finding('blocker', 'geometry.biot-missing', 'Seepage/groundwater coupling cases require plane-strain Biot geometry.'));
+        }
+        else {
+            if (biot.type !== 'plane_strain_biot_column') {
+                findings.push(finding('blocker', 'geometry.biot.type-invalid', `Unsupported Biot geometry type: ${String(biot.type)}.`));
+            }
+            pushPositiveNumberFindings(findings, [
+                [biot.widthM, 'geometry.biot.width', 'Biot column width'],
+                [biot.heightM, 'geometry.biot.height', 'Biot column height'],
+                [biot.thicknessM, 'geometry.biot.thickness', 'Biot column thickness'],
+            ]);
+            pushFiniteNumberFinding(findings, biot.initialPorePressureKpa, 'geometry.biot.initial-pore-pressure', 'Initial pore pressure', { nonNegative: true });
+            if (!isApproxEqual(domain.lengthM, biot.widthM, 1e-9)) {
+                findings.push(finding('blocker', 'geometry.biot.domain-width-mismatch', 'Biot column width must match the box-domain length.'));
+            }
+            if (!isApproxEqual(domain.depthM, biot.heightM, 1e-9)) {
+                findings.push(finding('blocker', 'geometry.biot.domain-height-mismatch', 'Biot column height must match the box-domain depth.'));
+            }
+            if (!isApproxEqual(domain.widthM, biot.thicknessM, 1e-9)) {
+                findings.push(finding('blocker', 'geometry.biot.domain-thickness-mismatch', 'Biot column thickness must match the box-domain width.'));
+            }
+            if (!Array.isArray(biot.timeStepsSeconds) || biot.timeStepsSeconds.length === 0) {
+                findings.push(finding('blocker', 'geometry.biot.time-steps-missing', 'Biot consolidation cases require at least one positive time step.'));
+            }
+            else {
+                if (biot.timeStepsSeconds.length < FEM_MIN_BIOT_TRANSIENT_STEPS) {
+                    findings.push(finding('blocker', 'geometry.biot.time-steps.too-few', `Biot consolidation cases require at least ${FEM_MIN_BIOT_TRANSIENT_STEPS} accepted transient steps for preview diagnostics.`));
+                }
+                let previousStepSeconds = 0;
+                let previousDeltaSeconds;
+                for (const [index, timeSeconds] of biot.timeStepsSeconds.entries()) {
+                    if (!Number.isFinite(timeSeconds) || timeSeconds <= previousStepSeconds) {
+                        findings.push(finding('blocker', `geometry.biot.time-steps.${index}.invalid`, 'Biot time steps must be finite, positive, and strictly increasing.'));
+                        break;
+                    }
+                    const deltaSeconds = timeSeconds - previousStepSeconds;
+                    if (previousDeltaSeconds != null &&
+                        deltaSeconds / previousDeltaSeconds > FEM_MAX_BIOT_TIME_STEP_GROWTH_RATIO) {
+                        findings.push(finding('blocker', `geometry.biot.time-steps.${index}.growth-ratio`, `Biot time-step growth ratio must not exceed ${FEM_MAX_BIOT_TIME_STEP_GROWTH_RATIO} between accepted steps.`));
+                        break;
+                    }
+                    previousStepSeconds = timeSeconds;
+                    previousDeltaSeconds = deltaSeconds;
+                }
+            }
+            if (!Array.isArray(biot.porePressureBoundaries) || biot.porePressureBoundaries.length === 0) {
+                findings.push(finding('blocker', 'geometry.biot.pressure-boundary-missing', 'Biot consolidation cases require at least one prescribed pore-pressure boundary.'));
+            }
+            else {
+                const boundaryIds = new Set();
+                const validPressureBoundaries = new Set(['top', 'bottom', 'left', 'right']);
+                for (const [index, boundary] of biot.porePressureBoundaries.entries()) {
+                    const prefix = `geometry.biot.pressure-boundaries.${index}`;
+                    if (!isRecord(boundary)) {
+                        findings.push(finding('blocker', `${prefix}.shape-invalid`, 'Pore-pressure boundary must be an object.'));
+                        continue;
+                    }
+                    pushUniqueStringFinding(findings, boundaryIds, boundary.id, `${prefix}.id`, 'Pore-pressure boundary id');
+                    if (!validPressureBoundaries.has(String(boundary.boundary))) {
+                        findings.push(finding('blocker', `${prefix}.boundary-invalid`, `Unsupported pore-pressure boundary: ${String(boundary.boundary)}.`));
+                    }
+                    pushFiniteNumberFinding(findings, boundary.porePressureKpa, `${prefix}.pore-pressure`, 'Prescribed pore pressure', { nonNegative: true });
+                }
+            }
+            findings.push(finding('review', 'biot.up-preview-only', 'Seepage/groundwater coupling uses an experimental deterministic 2D Biot u-p preview and is not production design evidence.'));
+        }
+    }
     if (caseFile.materials.length === 0) {
         findings.push(finding('blocker', 'material.missing', 'At least one material is required.'));
     }
@@ -733,6 +886,28 @@ export function validateFemAnalysisCase(caseFile) {
                     pushFiniteNumberFinding(findings, material.hydraulicConductivityMPerS, `${prefix}.hydraulic-conductivity`, 'Hydraulic conductivity', { positive: true });
                 }
             }
+            if (caseFile.objective === 'seepage_groundwater_coupling') {
+                if (material.model !== 'linear_elastic') {
+                    findings.push(finding('blocker', `${prefix}.biot-model-required`, 'Biot u-p preview requires a linear_elastic material with hydraulic coupling parameters.'));
+                }
+                const hasHydraulicX = material.hydraulicConductivityXMPerS != null || material.hydraulicConductivityMPerS != null;
+                if (!hasHydraulicX) {
+                    findings.push(finding('blocker', `${prefix}.hydraulic-conductivity-x-missing`, 'Biot u-p preview requires hydraulic conductivity in the x direction or an isotropic hydraulic conductivity.'));
+                }
+                else {
+                    pushFiniteNumberFinding(findings, material.hydraulicConductivityXMPerS ?? material.hydraulicConductivityMPerS, `${prefix}.hydraulic-conductivity-x`, 'Hydraulic conductivity X', { positive: true });
+                }
+                if (material.hydraulicConductivityYMPerS != null) {
+                    pushFiniteNumberFinding(findings, material.hydraulicConductivityYMPerS, `${prefix}.hydraulic-conductivity-y`, 'Hydraulic conductivity Y', { positive: true });
+                }
+                if (material.hydraulicConductivityMPerS != null) {
+                    pushFiniteNumberFinding(findings, material.hydraulicConductivityMPerS, `${prefix}.hydraulic-conductivity`, 'Isotropic hydraulic conductivity', { positive: true });
+                }
+                if (!isFiniteNumber(material.biotCoefficient) || material.biotCoefficient < 0 || material.biotCoefficient > 1) {
+                    findings.push(finding('blocker', `${prefix}.biot-coefficient-invalid`, 'Biot coefficient must be finite and between 0 and 1.'));
+                }
+                pushFiniteNumberFinding(findings, material.specificStorage1PerM, `${prefix}.specific-storage`, 'Specific storage', { positive: true });
+            }
             validateEvidenceRefs(findings, material.evidenceRefs, prefix);
             validateAssumptions(findings, material.assumptions, prefix);
         }
@@ -740,6 +915,9 @@ export function validateFemAnalysisCase(caseFile) {
     if (caseFile.objective === 'tunnel_volume_loss_settlement' && caseFile.loads.length > 0) {
         findings.push(finding('blocker', 'load.unsupported-for-objective', 'Tunnel volume-loss settlement previews use explicit volume loss and must not include pressure loads.'));
     }
+    if (caseFile.objective === 'seepage_groundwater_coupling' && caseFile.loads.length > 0) {
+        findings.push(finding('blocker', 'load.unsupported-for-objective', 'Biot u-p seepage previews currently use prescribed pore-pressure boundaries and must not include pressure loads.'));
+    }
     if (caseFile.loads.length === 0) {
         if (caseFile.objective === 'foundation_settlement') {
             findings.push(finding('blocker', 'load.missing', 'A raft pressure load is required.'));
@@ -775,6 +953,9 @@ export function validateFemAnalysisCase(caseFile) {
             if (caseFile.objective === 'staged_settlement_consolidation' && load.target !== 'ground_surface') {
                 findings.push(finding('blocker', `${prefix}.target-invalid`, 'Staged consolidation loads must target ground_surface.'));
             }
+            if (caseFile.objective === 'seepage_groundwater_coupling') {
+                findings.push(finding('blocker', `${prefix}.target-invalid`, 'Biot u-p seepage previews do not accept pressure loads.'));
+            }
             if (caseFile.objective === 'staged_settlement_consolidation' && consolidation) {
                 if (caseFile.loads.length !== consolidation.stages.length) {
                     findings.push(finding('blocker', 'load.stage-count-mismatch', 'Staged consolidation load count must match the consolidation stage count.'));
@@ -789,19 +970,30 @@ export function validateFemAnalysisCase(caseFile) {
         }
     }
     const { divisionsX, divisionsY, divisionsZ } = caseFile.mesh;
-    if (caseFile.mesh.elementType !== 'hex8') {
+    if (caseFile.mesh.elementType !== 'hex8' && caseFile.mesh.elementType !== 'quad4_plane_strain') {
         findings.push(finding('blocker', 'mesh.element-type-invalid', `Unsupported mesh element type: ${String(caseFile.mesh.elementType)}.`));
     }
+    if (caseFile.objective === 'seepage_groundwater_coupling' && caseFile.mesh.elementType !== 'quad4_plane_strain') {
+        findings.push(finding('blocker', 'mesh.element-type-biot-required', 'Biot u-p seepage previews require quad4_plane_strain mesh elements.'));
+    }
+    if (caseFile.objective !== 'seepage_groundwater_coupling' && caseFile.mesh.elementType !== 'hex8') {
+        findings.push(finding('blocker', 'mesh.element-type-hex8-required', 'Non-Biot FEM preview cases require hex8 mesh elements.'));
+    }
     if (!Number.isInteger(divisionsX) ||
         !Number.isInteger(divisionsY) ||
         !Number.isInteger(divisionsZ)) {
         findings.push(finding('blocker', 'mesh.divisions-integer', 'Mesh divisions must be finite integers.'));
     }
-    if (divisionsX < 2 || divisionsY < 2 || divisionsZ < 1) {
-        findings.push(finding('blocker', 'mesh.too-coarse', 'Mesh divisions must be at least 2 x 2 x 1.'));
-    }
-    if (Number.isInteger(divisionsX) && Number.isInteger(divisionsY) && Number.isInteger(divisionsZ)) {
-        const nodeCount = (divisionsX + 1) * (divisionsY + 1) * (divisionsZ + 1);
+    else {
+        if (caseFile.mesh.elementType === 'quad4_plane_strain') {
+            if (divisionsX < 1 || divisionsY < 1 || divisionsZ !== 1) {
+                findings.push(finding('blocker', 'mesh.quad4-plane-strain-invalid', 'Quad4 plane-strain meshes require divisionsX and divisionsY of at least 1 and divisionsZ exactly 1.'));
+            }
+        }
+        else if (divisionsX < 2 || divisionsY < 2 || divisionsZ < 1) {
+            findings.push(finding('blocker', 'mesh.too-coarse', 'Mesh divisions must be at least 2 x 2 x 1.'));
+        }
+        const nodeCount = expectedMeshCounts(caseFile.mesh).nodes;
         if (!Number.isFinite(nodeCount) || nodeCount > FEM_MAX_PREVIEW_MESH_NODES) {
             findings.push(finding('blocker', 'mesh.preview-node-limit', `Experimental FEM/WebGL previews are capped at ${FEM_MAX_PREVIEW_MESH_NODES} nodes.`));
         }
@@ -945,6 +1137,135 @@ function pushApproximateMatchFinding(findings, actual, expected, code, label, to
         findings.push(finding('blocker', code, `${label} must match the embedded FEM analysis case within ${tolerance}.`));
     }
 }
+function validateNonlinearSolverConvergenceReport(findings, manifest, expectedLoadSteps) {
+    const fallback = { forceBalanceTolerance: 1e-3, residualTolerance: 1e-6 };
+    const report = manifest.solverConvergence;
+    if (!isRecord(report)) {
+        findings.push(finding('blocker', 'result.solver-convergence.missing', 'Nonlinear column solver manifests must include explicit convergence policy and load-step residual history.'));
+        return fallback;
+    }
+    if (report.schemaVersion !== 'fem-solver-convergence-report.v1') {
+        findings.push(finding('blocker', 'result.solver-convergence.schema-invalid', 'Unsupported solver convergence report schema.'));
+    }
+    if (report.status !== 'converged' && report.status !== 'nonconverged') {
+        findings.push(finding('blocker', 'result.solver-convergence.status-invalid', 'Solver convergence status must be converged or nonconverged.'));
+    }
+    if (report.status === 'nonconverged') {
+        findings.push(finding('blocker', 'result.solver-convergence.nonconverged', 'Nonlinear column solver did not satisfy its configured convergence policy.'));
+    }
+    const policy = report.policy;
+    let forceBalanceTolerance = fallback.forceBalanceTolerance;
+    let residualTolerance = fallback.residualTolerance;
+    if (!isRecord(policy)) {
+        findings.push(finding('blocker', 'result.solver-convergence.policy.missing', 'Solver convergence report must include a policy object.'));
+    }
+    else {
+        if (policy.schemaVersion !== 'fem-convergence-policy.v1') {
+            findings.push(finding('blocker', 'result.solver-convergence.policy.schema-invalid', 'Solver convergence policy schema is unsupported.'));
+        }
+        if (pushFiniteNumberFinding(findings, policy.forceBalanceTolerance, 'result.solver-convergence.policy.force-balance-tolerance', 'Solver force-balance tolerance', { positive: true })) {
+            forceBalanceTolerance = policy.forceBalanceTolerance;
+        }
+        if (pushFiniteNumberFinding(findings, policy.residualTolerance, 'result.solver-convergence.policy.residual-tolerance', 'Solver residual tolerance', { positive: true })) {
+            residualTolerance = policy.residualTolerance;
+        }
+        pushFiniteNumberFinding(findings, policy.porePressureMassBalanceTolerance, 'result.solver-convergence.policy.pore-pressure-mass-balance-tolerance', 'Solver pore-pressure mass-balance tolerance', { positive: true });
+        if (!Number.isInteger(policy.maxIterations) || policy.maxIterations < 1) {
+            findings.push(finding('blocker', 'result.solver-convergence.policy.max-iterations-invalid', 'Solver maxIterations must be a positive integer.'));
+        }
+        if (!Number.isInteger(policy.minAcceptedSteps) || policy.minAcceptedSteps < 1) {
+            findings.push(finding('blocker', 'result.solver-convergence.policy.min-accepted-steps-invalid', 'Solver minAcceptedSteps must be a positive integer.'));
+        }
+    }
+    if (!Array.isArray(report.loadSteps)) {
+        findings.push(finding('blocker', 'result.solver-convergence.load-steps.invalid', 'Solver convergence loadSteps must be an array.'));
+        return { forceBalanceTolerance, residualTolerance };
+    }
+    if (report.loadSteps.length !== expectedLoadSteps) {
+        findings.push(finding('blocker', 'result.solver-convergence.load-steps.count-mismatch', 'Solver convergence load steps must match consolidation stages.'));
+    }
+    const validTerminationReasons = new Set([
+        'converged',
+        'max_iterations',
+        'force_residual_exceeded',
+        'yield_residual_exceeded',
+        'material_nonconvergence',
+        'consolidation_nonconvergence',
+    ]);
+    for (const [index, step] of report.loadSteps.entries()) {
+        const prefix = `result.solver-convergence.loadSteps.${index}`;
+        if (!isRecord(step)) {
+            findings.push(finding('blocker', `${prefix}.shape-invalid`, 'Solver convergence load step must be an object.'));
+            continue;
+        }
+        const stepOk = pushFiniteNumberFinding(findings, step.step, `${prefix}.step`, 'Solver convergence load-step number', { positive: true });
+        if (stepOk && (!Number.isInteger(step.step) || step.step !== index + 1)) {
+            findings.push(finding('blocker', `${prefix}.step.sequence-invalid`, 'Solver convergence load-step numbers must be sequential.'));
+        }
+        if (step.stageId != null && !isNonEmptyString(step.stageId)) {
+            findings.push(finding('blocker', `${prefix}.stage-id.invalid`, 'Solver convergence stageId must be a non-empty string when present.'));
+        }
+        if (!Number.isInteger(step.iterations) || step.iterations < 0) {
+            findings.push(finding('blocker', `${prefix}.iterations.invalid`, 'Solver convergence iterations must be a non-negative integer.'));
+        }
+        const residualOk = pushFiniteNumberFinding(findings, step.residualRatio, `${prefix}.residual-ratio`, 'Solver convergence residual ratio', { nonNegative: true });
+        const forceToleranceOk = pushFiniteNumberFinding(findings, step.forceBalanceTolerance, `${prefix}.force-balance-tolerance`, 'Solver convergence force-balance tolerance', { positive: true });
+        const stepForceTolerance = forceToleranceOk ? step.forceBalanceTolerance : forceBalanceTolerance;
+        if (step.yieldResidualRatio != null) {
+            const yieldResidualOk = pushFiniteNumberFinding(findings, step.yieldResidualRatio, `${prefix}.yield-residual-ratio`, 'Solver convergence yield residual ratio', { nonNegative: true });
+            const stepResidualTolerance = isFiniteNumber(step.residualTolerance) && step.residualTolerance > 0
+                ? step.residualTolerance
+                : residualTolerance;
+            if (yieldResidualOk && step.yieldResidualRatio > stepResidualTolerance) {
+                findings.push(finding('blocker', `${prefix}.yield-residual-too-large`, 'Solver convergence yield residual exceeds the reported tolerance.'));
+            }
+        }
+        if (step.residualTolerance != null) {
+            pushFiniteNumberFinding(findings, step.residualTolerance, `${prefix}.residual-tolerance`, 'Solver convergence residual tolerance', { positive: true });
+        }
+        if (typeof step.converged !== 'boolean') {
+            findings.push(finding('blocker', `${prefix}.converged.invalid`, 'Solver convergence load-step converged must be boolean.'));
+        }
+        else if (!step.converged) {
+            findings.push(finding('blocker', `${prefix}.nonconverged`, 'Solver convergence load step did not satisfy the reported policy.'));
+        }
+        if (typeof step.terminationReason !== 'string' || !validTerminationReasons.has(step.terminationReason)) {
+            findings.push(finding('blocker', `${prefix}.termination-reason.invalid`, 'Solver convergence termination reason is unsupported.'));
+        }
+        if (residualOk && step.residualRatio > stepForceTolerance) {
+            findings.push(finding('blocker', `${prefix}.force-residual-too-large`, 'Solver convergence force residual exceeds the reported tolerance.'));
+        }
+        if (!Array.isArray(step.residualHistory) || step.residualHistory.length === 0) {
+            findings.push(finding('blocker', `${prefix}.residual-history.missing`, 'Solver convergence load step must include non-empty residual history.'));
+            continue;
+        }
+        for (const [historyIndex, history] of step.residualHistory.entries()) {
+            const historyPrefix = `${prefix}.residualHistory.${historyIndex}`;
+            if (!isRecord(history)) {
+                findings.push(finding('blocker', `${historyPrefix}.shape-invalid`, 'Solver convergence residual history entry must be an object.'));
+                continue;
+            }
+            if (!Number.isInteger(history.iteration) || history.iteration < 0) {
+                findings.push(finding('blocker', `${historyPrefix}.iteration.invalid`, 'Solver convergence residual history iteration must be a non-negative integer.'));
+            }
+            pushFiniteNumberFinding(findings, history.residualRatio, `${historyPrefix}.residual-ratio`, 'Solver convergence residual history ratio', { nonNegative: true });
+            pushFiniteNumberFinding(findings, history.forceBalanceTolerance, `${historyPrefix}.force-balance-tolerance`, 'Solver convergence residual history force-balance tolerance', { positive: true });
+            if (history.yieldResidualRatio != null) {
+                pushFiniteNumberFinding(findings, history.yieldResidualRatio, `${historyPrefix}.yield-residual-ratio`, 'Solver convergence residual history yield residual ratio', { nonNegative: true });
+            }
+            if (history.residualTolerance != null) {
+                pushFiniteNumberFinding(findings, history.residualTolerance, `${historyPrefix}.residual-tolerance`, 'Solver convergence residual history residual tolerance', { positive: true });
+            }
+            if (typeof history.converged !== 'boolean') {
+                findings.push(finding('blocker', `${historyPrefix}.converged.invalid`, 'Solver convergence residual history converged must be boolean.'));
+            }
+        }
+    }
+    if (report.status === 'nonconverged' && !isRecord(report.failure)) {
+        findings.push(finding('blocker', 'result.solver-convergence.failure.missing', 'Nonconverged solver reports must include failure details.'));
+    }
+    return { forceBalanceTolerance, residualTolerance };
+}
 function validateResultEnvelopeSemantics(findings, manifest) {
     const { envelope, analysisCase } = manifest;
     const maxSettlementOk = pushFiniteNumberFinding(findings, envelope.maxSettlementMm, 'result.envelope.max-settlement', 'Envelope max settlement', { nonNegative: true });
@@ -960,6 +1281,7 @@ function validateResultEnvelopeSemantics(findings, manifest) {
         ['excavation_deformation', ['builtin-staged-excavation-demo']],
         ['tunnel_volume_loss_settlement', ['builtin-tunnel-volume-loss-demo']],
         ['staged_settlement_consolidation', ['builtin-staged-consolidation-1d', 'builtin-nonlinear-column-v0']],
+        ['seepage_groundwater_coupling', ['builtin-biot-up-plane-strain-v0']],
     ]);
     const expectedBackends = expectedBackendByObjective.get(analysisCase.objective);
     if (expectedBackends && !expectedBackends.includes(manifest.backend.id)) {
@@ -1077,6 +1399,7 @@ function validateResultEnvelopeSemantics(findings, manifest) {
         pushApproximateMatchFinding(findings, envelope.drainagePathM, expectedDrainagePathM, 'result.envelope.consolidation-drainage-path-mismatch', 'Consolidation drainage path', 0.001);
         pushApproximateMatchFinding(findings, envelope.consolidationDurationYears, expectedDurationYears, 'result.envelope.consolidation-duration-mismatch', 'Consolidation duration', 0.001);
         if (manifest.backend.id === 'builtin-nonlinear-column-v0') {
+            const solverTolerances = validateNonlinearSolverConvergenceReport(findings, manifest, consolidation.stages.length);
             const loadStepsOk = pushFiniteNumberFinding(findings, envelope.solverLoadSteps, 'result.envelope.solver-load-steps', 'Envelope solver load steps', { positive: true });
             const iterationsOk = pushFiniteNumberFinding(findings, envelope.solverIterations, 'result.envelope.solver-iterations', 'Envelope solver iterations', { positive: true });
             const solverResidualOk = pushFiniteNumberFinding(findings, envelope.maxSolverResidualRatio, 'result.envelope.max-solver-residual-ratio', 'Envelope max solver residual ratio', { nonNegative: true });
@@ -1088,14 +1411,105 @@ function validateResultEnvelopeSemantics(findings, manifest) {
             if (iterationsOk && !Number.isInteger(envelope.solverIterations)) {
                 findings.push(finding('blocker', 'result.envelope.solver-iterations-integer', 'Nonlinear column solver iterations must be an integer.'));
             }
-            if (solverResidualOk && envelope.maxSolverResidualRatio > 1e-3) {
+            if (solverResidualOk && envelope.maxSolverResidualRatio > solverTolerances.forceBalanceTolerance) {
                 findings.push(finding('blocker', 'result.envelope.solver-residual-too-large', 'Nonlinear column solver residual exceeds the force-balance tolerance.'));
             }
-            if (yieldResidualOk && envelope.maxYieldResidualRatio > 1e-6) {
+            if (yieldResidualOk && envelope.maxYieldResidualRatio > solverTolerances.residualTolerance) {
                 findings.push(finding('blocker', 'result.envelope.yield-residual-too-large', 'Nonlinear column solver yield residual exceeds the material return-map tolerance.'));
             }
         }
     }
+    if (analysisCase.objective === 'seepage_groundwater_coupling') {
+        const biot = analysisCase.geometry.biot;
+        if (!biot)
+            return;
+        const boundaryPressureValues = biot.porePressureBoundaries.map((boundary) => boundary.porePressureKpa);
+        const expectedMaxPressureKpa = Math.max(biot.initialPorePressureKpa, ...boundaryPressureValues);
+        const minPorePressureOk = pushFiniteNumberFinding(findings, envelope.minPorePressureKpa, 'result.envelope.min-pore-pressure', 'Envelope minimum pore pressure', { nonNegative: true });
+        const maxPorePressureOk = pushFiniteNumberFinding(findings, envelope.maxPorePressureKpa, 'result.envelope.max-pore-pressure', 'Envelope maximum pore pressure', { nonNegative: true });
+        const maxExcessOk = pushFiniteNumberFinding(findings, envelope.maxExcessPorePressureKpa, 'result.envelope.max-excess-pore-pressure', 'Envelope maximum excess pore pressure', { nonNegative: true });
+        pushFiniteNumberFinding(findings, envelope.maxBiotCouplingKpa, 'result.envelope.max-biot-coupling', 'Envelope maximum Biot coupling', { nonNegative: true });
+        const massBalanceOk = pushFiniteNumberFinding(findings, envelope.porePressureMassBalanceErrorRatio, 'result.envelope.pore-pressure-mass-balance-error-ratio', 'Envelope pore-pressure mass-balance error ratio', { nonNegative: true });
+        pushFiniteNumberFinding(findings, envelope.maxFreePorePressureResidualM3PerS, 'result.envelope.max-free-pore-pressure-residual', 'Envelope maximum free pore-pressure residual', { nonNegative: true });
+        pushFiniteNumberFinding(findings, envelope.freePorePressureResidualL1M3PerS, 'result.envelope.free-pore-pressure-residual-l1', 'Envelope free pore-pressure residual L1 norm', { nonNegative: true });
+        pushFiniteNumberFinding(findings, envelope.prescribedPorePressureResidualL1M3PerS, 'result.envelope.prescribed-pore-pressure-residual-l1', 'Envelope prescribed pore-pressure residual L1 norm', { nonNegative: true });
+        const averagePorePressureOk = pushFiniteNumberFinding(findings, envelope.averagePorePressureKpa, 'result.envelope.average-pore-pressure', 'Envelope average pore pressure', { nonNegative: true });
+        const averageFreePorePressureOk = pushFiniteNumberFinding(findings, envelope.averageFreePorePressureKpa, 'result.envelope.average-free-pore-pressure', 'Envelope average free pore pressure', { nonNegative: true });
+        const dissipationRatioOk = pushFiniteNumberFinding(findings, envelope.porePressureDissipationRatio, 'result.envelope.pore-pressure-dissipation-ratio', 'Envelope pore-pressure dissipation ratio', { nonNegative: true });
+        pushFiniteNumberFinding(findings, envelope.maxPorePressureChangeRateKpaPerS, 'result.envelope.max-pore-pressure-change-rate', 'Envelope maximum pore-pressure change rate', { nonNegative: true });
+        const timeStepCountOk = pushFiniteNumberFinding(findings, envelope.timeStepCount, 'result.envelope.time-step-count', 'Envelope time-step count', { positive: true });
+        const coupledUnknownsOk = pushFiniteNumberFinding(findings, envelope.coupledUnknownCount, 'result.envelope.coupled-unknown-count', 'Envelope coupled unknown count', { positive: true });
+        const displacementDofsOk = pushFiniteNumberFinding(findings, envelope.displacementDofCount, 'result.envelope.displacement-dof-count', 'Envelope displacement DOF count', { positive: true });
+        const porePressureDofsOk = pushFiniteNumberFinding(findings, envelope.porePressureDofCount, 'result.envelope.pore-pressure-dof-count', 'Envelope pore-pressure DOF count', { positive: true });
+        if (minPorePressureOk && maxPorePressureOk && envelope.minPorePressureKpa > envelope.maxPorePressureKpa) {
+            findings.push(finding('blocker', 'result.envelope.pore-pressure-range-invalid', 'Envelope minimum pore pressure cannot exceed maximum pore pressure.'));
+        }
+        if (maxPorePressureOk && envelope.maxPorePressureKpa > expectedMaxPressureKpa + 1e-6) {
+            findings.push(finding('blocker', 'result.envelope.pore-pressure-upper-bound-invalid', 'Envelope maximum pore pressure cannot exceed the initial or prescribed boundary pressure envelope.'));
+        }
+        if (averagePorePressureOk && minPorePressureOk && maxPorePressureOk && (envelope.averagePorePressureKpa < envelope.minPorePressureKpa - 1e-6 ||
+            envelope.averagePorePressureKpa > envelope.maxPorePressureKpa + 1e-6)) {
+            findings.push(finding('blocker', 'result.envelope.average-pore-pressure-range-invalid', 'Envelope average pore pressure must stay within the reported pore-pressure range.'));
+        }
+        if (averageFreePorePressureOk && maxPorePressureOk && envelope.averageFreePorePressureKpa > envelope.maxPorePressureKpa + 1e-6) {
+            findings.push(finding('blocker', 'result.envelope.average-free-pore-pressure-range-invalid', 'Envelope average free pore pressure cannot exceed the reported maximum pore pressure.'));
+        }
+        if (dissipationRatioOk && envelope.porePressureDissipationRatio > 1) {
+            findings.push(finding('blocker', 'result.envelope.pore-pressure-dissipation-ratio-invalid', 'Envelope pore-pressure dissipation ratio must be between 0 and 1.'));
+        }
+        if (maxExcessOk && maxPorePressureOk) {
+            pushApproximateMatchFinding(findings, envelope.maxExcessPorePressureKpa, envelope.maxPorePressureKpa, 'result.envelope.max-excess-pore-pressure-mismatch', 'Maximum excess pore pressure', 1e-6);
+        }
+        if (timeStepCountOk && (!Number.isInteger(envelope.timeStepCount) || envelope.timeStepCount !== biot.timeStepsSeconds.length)) {
+            findings.push(finding('blocker', 'result.envelope.time-step-count-mismatch', 'Biot envelope time-step count must match the embedded time-step schedule.'));
+        }
+        if (timeStepCountOk && envelope.timeStepCount < FEM_MIN_BIOT_TRANSIENT_STEPS) {
+            findings.push(finding('blocker', 'result.envelope.time-step-count-too-small', 'Biot envelope time-step count is below the preview transient-step policy.'));
+        }
+        if (coupledUnknownsOk && !Number.isInteger(envelope.coupledUnknownCount)) {
+            findings.push(finding('blocker', 'result.envelope.coupled-unknown-count-integer', 'Coupled unknown count must be an integer.'));
+        }
+        if (displacementDofsOk && !Number.isInteger(envelope.displacementDofCount)) {
+            findings.push(finding('blocker', 'result.envelope.displacement-dof-count-integer', 'Displacement DOF count must be an integer.'));
+        }
+        if (porePressureDofsOk && !Number.isInteger(envelope.porePressureDofCount)) {
+            findings.push(finding('blocker', 'result.envelope.pore-pressure-dof-count-integer', 'Pore-pressure DOF count must be an integer.'));
+        }
+        if (coupledUnknownsOk && displacementDofsOk && porePressureDofsOk && envelope.coupledUnknownCount > envelope.displacementDofCount + envelope.porePressureDofCount) {
+            findings.push(finding('blocker', 'result.envelope.coupled-unknown-count-mismatch', 'Coupled unknown count cannot exceed displacement plus pore-pressure DOF counts.'));
+        }
+        if (massBalanceOk && envelope.porePressureMassBalanceErrorRatio > 1e-3) {
+            findings.push(finding('blocker', 'result.envelope.pore-pressure-mass-balance-too-large', 'Biot pore-pressure mass-balance error ratio exceeds the preview tolerance.'));
+        }
+        pushApproximateMatchFinding(findings, envelope.totalLoadKn, 0, 'result.envelope.biot-total-load-invalid', 'Biot preview total load', 0.001);
+        pushApproximateMatchFinding(findings, envelope.reactionKn, 0, 'result.envelope.biot-reaction-invalid', 'Biot preview reaction', 0.001);
+        if (maxSettlementOk && isFiniteNumber(envelope.finalSettlementMm)) {
+            pushApproximateMatchFinding(findings, envelope.maxSettlementMm, envelope.finalSettlementMm, 'result.envelope.biot-max-settlement-mismatch', 'Biot maximum settlement', 0.001);
+        }
+        const pressureAudit = manifest.pressureAudit;
+        if (!pressureAudit) {
+            findings.push(finding('blocker', 'result.pressure-audit.missing', 'Biot result manifests must include a pressure audit.'));
+        }
+        else {
+            const pressureAuditEntries = [
+                ['freePorePressureResidualL1M3PerS', 'free-pore-pressure-residual-l1', 'Free pore-pressure residual L1 norm'],
+                ['prescribedPorePressureResidualL1M3PerS', 'prescribed-pore-pressure-residual-l1', 'Prescribed pore-pressure residual L1 norm'],
+                ['netPrescribedPressureBoundaryFlowM3PerS', 'net-prescribed-pressure-boundary-flow', 'Net prescribed pressure boundary flow'],
+                ['appliedNodalFluxSumM3PerS', 'applied-nodal-flux-sum', 'Applied nodal flux sum'],
+                ['storageRateSumM3PerS', 'storage-rate-sum', 'Storage-rate sum'],
+                ['couplingRateSumM3PerS', 'coupling-rate-sum', 'Coupling-rate sum'],
+                ['darcyFlowRateSumM3PerS', 'darcy-flow-rate-sum', 'Darcy flow-rate sum'],
+            ];
+            for (const [key, code, label] of pressureAuditEntries) {
+                pushFiniteNumberFinding(findings, pressureAudit[key], `result.pressure-audit.${code}`, label);
+            }
+            pushApproximateMatchFinding(findings, pressureAudit.freePorePressureResidualL1M3PerS, envelope.freePorePressureResidualL1M3PerS, 'result.pressure-audit.free-residual-envelope-mismatch', 'Pressure-audit free residual', 1e-12);
+            pushApproximateMatchFinding(findings, pressureAudit.prescribedPorePressureResidualL1M3PerS, envelope.prescribedPorePressureResidualL1M3PerS, 'result.pressure-audit.prescribed-residual-envelope-mismatch', 'Pressure-audit prescribed residual', 1e-12);
+        }
+    }
+    else if (manifest.pressureAudit != null) {
+        findings.push(finding('blocker', 'result.pressure-audit.unexpected', 'Pressure audit is only valid for Biot u-p seepage result manifests.'));
+    }
 }
 export function validateFemResultManifest(manifest) {
     const findings = [];
@@ -1130,6 +1544,7 @@ export function validateFemResultManifest(manifest) {
         'builtin-tunnel-volume-loss-demo',
         'builtin-staged-consolidation-1d',
         'builtin-nonlinear-column-v0',
+        'builtin-biot-up-plane-strain-v0',
     ]);
     if (!validBackendIds.has(manifest.backend.id)) {
         findings.push(finding('blocker', 'result.backend.id-invalid', `Unsupported FEM result backend: ${String(manifest.backend.id)}.`));
@@ -1170,12 +1585,7 @@ export function validateFemResultManifest(manifest) {
     }
     pushIndexArrayFindings(findings, 'tri', visualization.tri, nodeCount, 3);
     pushIndexArrayFindings(findings, 'edge', visualization.edge, nodeCount, 2);
-    const expectedMeshNodes = (manifest.analysisCase.mesh.divisionsX + 1) *
-        (manifest.analysisCase.mesh.divisionsY + 1) *
-        (manifest.analysisCase.mesh.divisionsZ + 1);
-    const expectedMeshElements = manifest.analysisCase.mesh.divisionsX *
-        manifest.analysisCase.mesh.divisionsY *
-        manifest.analysisCase.mesh.divisionsZ;
+    const { nodes: expectedMeshNodes, elements: expectedMeshElements } = expectedMeshCounts(manifest.analysisCase.mesh);
     const meshDivisions = manifest.mesh.divisions;
     if (!Number.isInteger(manifest.mesh.nodes) || manifest.mesh.nodes !== expectedMeshNodes) {
         findings.push(finding('blocker', 'result.mesh.nodes-mismatch', 'Result mesh node count must match the embedded analysis case mesh divisions.'));
@@ -1232,6 +1642,12 @@ export function validateFemResultManifest(manifest) {
             if (frame.color.length / 3 !== nodeCount) {
                 findings.push(finding('blocker', `result.frames.${index}.color.node-count-mismatch`, 'Frame color vectors must match base nodes.'));
             }
+            if (frame.scalarValues != null) {
+                pushFiniteArrayFindings(findings, `frames.${index}.scalarValues`, frame.scalarValues, 1);
+                if (frame.scalarValues.length !== nodeCount) {
+                    findings.push(finding('blocker', `result.frames.${index}.scalar-values.node-count-mismatch`, 'Frame scalarValues must match base nodes.'));
+                }
+            }
         }
     }
     validateOptionalResultMetadata(findings, manifest, nodeCount, outlineNodeCount);