@bedrock-engineer/bro-xml-parser 0.1.7 → 0.3.0

package/dist/resolvers/bore-resolvers.js

@@ -4,9 +4,9 @@
  * Functions to parse and convert bore-specific data structures
  */
 // Import shared utilities
-import { createXPathTextGetter, createNamespaceResolver, createLayerParser, getTextContent, findChildElement, extractArray, parseCSVPairs, parseCSVRows, } from "./bore-resolver-utils.js";
+import { createXPathTextGetter, createNamespaceResolver, extractOptionalFields, getTextContent, findChildElement, extractArray, parseCSVPairs, parseCSVRows, } from "./bore-resolver-utils.js";
 // Import type resolvers
-import { parseBoolean, parseFloat, parseJaNee } from "./type-resolvers.js";
+import { parseBoolean, parseFloat, parseDate } from "./type-resolvers.js";
 /**
  * Parse dispersedInhomogeneity field
  * Special case: 'geen' (none) means false, any other value means true
@@ -35,118 +35,186 @@ function parseDispersedInhomogeneity(text) {
  * - Tertiary soil constituent
  * - Grain shape properties for coarse fractions
  */
-export const processBHRGTLayerData = createLayerParser({
-    layerXPath: ".//bhrgtcom:layer",
-    requiredFields: {
-        upperBoundary: "./bhrgtcom:upperBoundary",
-        lowerBoundary: "./bhrgtcom:lowerBoundary",
-        soilName: "./bhrgtcom:soil/bhrgtcom:geotechnicalSoilName",
-        soilNameKey: "geotechnicalSoilName",
+// Layer-level fields shared by soil and rock layers (outside <soil>/<rock>).
+const BHRGT_BASE_FIELDS = [
+    { xpath: "./bhrgtcom:upperBoundaryDetermination", key: "upperBoundaryDetermination" },
+    { xpath: "./bhrgtcom:lowerBoundaryDetermination", key: "lowerBoundaryDetermination" },
+    { xpath: "./bhrgtcom:anthropogenic", key: "anthropogenic", transform: parseBoolean },
+    { xpath: "./bhrgtcom:slant", key: "slant", transform: parseBoolean },
+    { xpath: "./bhrgtcom:bedding", key: "bedding", omitIfEmpty: true },
+    {
+        xpath: "./bhrgtcom:compositeLayer",
+        key: "compositeLayer",
+        transform: parseBoolean,
+        omitIfEmpty: true,
+    },
+    { xpath: "./bhrgtcom:activityType", key: "activityType", omitIfEmpty: true },
+    { xpath: "./bhrgtcom:bedded", key: "bedded", transform: parseBoolean },
+    {
+        xpath: "./bhrgtcom:internalStructureIntact",
+        key: "internalStructureIntact",
+        transform: parseBoolean,
+    },
+    { xpath: "./bhrgtcom:specialMaterial", key: "specialMaterial", omitIfEmpty: true },
+];
+// Soil-description fields (inside <soil>) for soil layers only.
+const BHRGT_SOIL_FIELDS = [
+    { xpath: "./bhrgtcom:soil/bhrgtcom:soilNameNEN5104", key: "soilNameNEN5104", omitIfEmpty: true },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:gravelContentClassNEN5104",
+        key: "gravelContentClassNEN5104",
+        omitIfEmpty: true,
+    },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:organicMatterContentClassNEN5104",
+        key: "organicMatterContentClassNEN5104",
+        omitIfEmpty: true,
+    },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:tertiaryConstituent", key: "tertiaryConstituent" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:colour", key: "color", omitIfEmpty: true },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:dispersedInhomogeneity",
+        key: "dispersedInhomogeneity",
+        transform: parseDispersedInhomogeneity,
+    },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:organicMatterContentClass", key: "organicMatterContentClass" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:carbonateContentClass", key: "carbonateContentClass" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:sandMedianClass", key: "sandMedianClass" },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:gravelMedianClass",
+        key: "gravelMedianClass",
+        omitIfEmpty: true,
+    },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:geotechnicalDepositionalCharacteristic",
+        key: "geotechnicalDepositionalCharacteristic",
+        omitIfEmpty: true,
+    },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:interbedding", key: "interbedding", omitIfEmpty: true },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:mixed", key: "mixed", transform: parseBoolean },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:mottled", key: "mottled", transform: parseBoolean },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:fineSoilConsistency", key: "fineSoilConsistency" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:organicSoilConsistency", key: "organicSoilConsistency" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:organicSoilTexture", key: "organicSoilTexture" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:peatTensileStrength", key: "peatTensileStrength" },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:crossBedding", key: "crossBedding", omitIfEmpty: true },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:gradedBedding", key: "gradedBedding", omitIfEmpty: true },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:mixingType", key: "mixingType", omitIfEmpty: true },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:fineGravelContentClass",
+        key: "fineGravelContentClass",
+        omitIfEmpty: true,
     },
-    optionalFields: [
-        // Layer-level fields (outside <soil>)
-        {
-            xpath: "./bhrgtcom:upperBoundaryDetermination",
-            key: "upperBoundaryDetermination",
-        },
-        {
-            xpath: "./bhrgtcom:lowerBoundaryDetermination",
-            key: "lowerBoundaryDetermination",
-        },
-        {
-            xpath: "./bhrgtcom:anthropogenic",
-            key: "anthropogenic",
-            transform: parseJaNee,
-        },
-        {
-            xpath: "./bhrgtcom:slant",
-            key: "slant",
-            transform: parseJaNee,
-        },
-        // Soil-level fields (inside <soil>)
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:tertiaryConstituent",
-            key: "tertiaryConstituent",
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:colour",
-            key: "color",
-            omitIfEmpty: true,
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:dispersedInhomogeneity",
-            key: "dispersedInhomogeneity",
-            transform: parseDispersedInhomogeneity,
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:organicMatterContentClass",
-            key: "organicMatterContentClass",
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:carbonateContentClass",
-            key: "carbonateContentClass",
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:sandMedianClass",
-            key: "sandMedianClass",
-        },
-        // Layer structure properties (at layer level)
-        {
-            xpath: "./bhrgtcom:bedded",
-            key: "bedded",
-            transform: parseJaNee,
-        },
-        {
-            xpath: "./bhrgtcom:internalStructureIntact",
-            key: "internalStructureIntact",
-            transform: parseJaNee,
-        },
-        // Soil structure properties (inside <soil>)
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:mixed",
-            key: "mixed",
-            transform: parseJaNee,
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:mottled",
-            key: "mottled",
-            transform: parseJaNee,
-        },
-        // Fine-grained soil consistency
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:fineSoilConsistency",
-            key: "fineSoilConsistency",
-        },
-        // Organic soil properties
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:organicSoilConsistency",
-            key: "organicSoilConsistency",
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:organicSoilTexture",
-            key: "organicSoilTexture",
-        },
-        {
-            xpath: "./bhrgtcom:soil/bhrgtcom:peatTensileStrength",
-            key: "peatTensileStrength",
-        },
-    ],
-    // Extract nested grainshape object
-    postProcess: (layerNode, layer, adapter, namespaces) => {
-        const nsResolver = createNamespaceResolver(namespaces);
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:mediumCoarseGravelContentClass",
+        key: "mediumCoarseGravelContentClass",
+        omitIfEmpty: true,
+    },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:veryCoarseGravelContentClass",
+        key: "veryCoarseGravelContentClass",
+        omitIfEmpty: true,
+    },
+    {
+        xpath: "./bhrgtcom:soil/bhrgtcom:sandSortingNEN5104",
+        key: "sandSortingNEN5104",
+        omitIfEmpty: true,
+    },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:peatType", key: "peatType", omitIfEmpty: true },
+    { xpath: "./bhrgtcom:soil/bhrgtcom:depositionalAge", key: "depositionalAge", omitIfEmpty: true },
+];
+/**
+ * Parse a BHR-GT `rock` element into a RockDescription.
+ */
+function parseRockDescription(rockNode, adapter, namespaces) {
+    const nsResolver = createNamespaceResolver(namespaces);
+    const getText = createXPathTextGetter(rockNode, adapter, namespaces);
+    const textList = (xpath) => adapter
+        .evaluateXPathAll(rockNode, xpath, nsResolver)
+        .map((n) => n.textContent?.trim() ?? "")
+        .filter((s) => s !== "");
+    const rock = {
+        rockType: getText("./bhrgtcom:rockType"),
+        cementType: getText("./bhrgtcom:cementType"),
+        colour: getText("./bhrgtcom:colour"),
+        tertiaryRockConstituent: textList("./bhrgtcom:tertiaryRockConstituent"),
+        interbedding: getText("./bhrgtcom:interbedding"),
+        dispersedInhomogeneity: textList("./bhrgtcom:dispersedInhomogeneity"),
+        carbonateContentClass: getText("./bhrgtcom:carbonateContentClass"),
+        crossBedding: getText("./bhrgtcom:crossBedding"),
+        gradedBedding: getText("./bhrgtcom:gradedBedding"),
+        voidsPresent: getText("./bhrgtcom:voidsPresent"),
+        voidDistribution: getText("./bhrgtcom:voidDistribution"),
+        stability: getText("./bhrgtcom:stability"),
+        strengthClass: getText("./bhrgtcom:strengthClass"),
+        weathered: getText("./bhrgtcom:weathered"),
+    };
+    const weatheringNode = adapter.evaluateXPath(rockNode, "./bhrgtcom:weatheringDegree", nsResolver);
+    if (weatheringNode) {
+        const getW = createXPathTextGetter(weatheringNode, adapter, namespaces);
+        rock.weatheringDegree = {
+            discolouration: getW("./bhrgtcom:discolouration"),
+            disintegration: getW("./bhrgtcom:disintegration"),
+            decomposition: getW("./bhrgtcom:decomposition"),
+        };
+    }
+    return rock;
+}
+/**
+ * Parse BHR-GT descriptive-log layers into a discriminated union of soil / rock
+ * layers. A layer describes either soil or rock; we branch on which is present
+ * so rock layers aren't forced through the soil shape (and vice versa).
+ */
+export function processBHRGTLayerData(_value, context) {
+    const { node, adapter, namespaces } = context;
+    const nsResolver = createNamespaceResolver(namespaces);
+    const layerNodes = adapter.evaluateXPathAll(node, ".//bhrgtcom:layer", nsResolver);
+    const layers = [];
+    for (const layerNode of layerNodes) {
+        const getText = createXPathTextGetter(layerNode, adapter, namespaces);
+        const upperBoundary = parseFloat(getText("./bhrgtcom:upperBoundary"));
+        const lowerBoundary = parseFloat(getText("./bhrgtcom:lowerBoundary"));
+        if (upperBoundary === null || lowerBoundary === null) {
+            continue;
+        }
+        // Spread extracted optionals first, then the guaranteed fields, so the
+        // required boundaries/discriminant keep their exact (non-optional) types.
+        const base = {
+            ...extractOptionalFields(BHRGT_BASE_FIELDS, layerNode, adapter, namespaces),
+            upperBoundary,
+            lowerBoundary,
+        };
+        // A layer describes rock or soil - branch on which element is present.
+        const rockNode = adapter.evaluateXPath(layerNode, "./bhrgtcom:rock", nsResolver);
+        if (rockNode) {
+            layers.push({
+                ...base,
+                material: "rock",
+                rock: parseRockDescription(rockNode, adapter, namespaces),
+            });
+            continue;
+        }
+        const soilLayer = {
+            ...base,
+            ...extractOptionalFields(BHRGT_SOIL_FIELDS, layerNode, adapter, namespaces),
+            material: "soil",
+            geotechnicalSoilName: getText("./bhrgtcom:soil/bhrgtcom:geotechnicalSoilName") ?? "",
+        };
         const grainshapeNode = adapter.evaluateXPath(layerNode, "./bhrgtcom:soil/bhrgtcom:grainshape", nsResolver);
         if (grainshapeNode) {
-            const getText = createXPathTextGetter(grainshapeNode, adapter, namespaces);
+            const getGrain = createXPathTextGetter(grainshapeNode, adapter, namespaces);
             const grainshape = {
-                sizeFraction: getText("./bhrgtcom:sizeFraction"),
-                angularity: getText("./bhrgtcom:angularity"),
-                sphericity: getText("./bhrgtcom:sphericity"),
-                roughness: getText("./bhrgtcom:roughness"),
+                sizeFraction: getGrain("./bhrgtcom:sizeFraction"),
+                angularity: getGrain("./bhrgtcom:angularity"),
+                sphericity: getGrain("./bhrgtcom:sphericity"),
+                roughness: getGrain("./bhrgtcom:roughness"),
             };
-            layer.grainshape = grainshape;
+            soilLayer.grainshape = grainshape;
         }
-    },
-});
+        layers.push(soilLayer);
+    }
+    return layers;
+}
 /**
  * Empty structure constants for determinations
  */
@@ -156,6 +224,7 @@ const EMPTY_CONSISTENCY_LIMITS = {
     fractionLarger500um: null,
     usedMedium: null,
     performanceIrregularity: null,
+    conusType: null,
     liquidLimit: null,
     plasticLimit: null,
     plasticityIndex: null,
@@ -185,7 +254,11 @@ const EMPTY_SATURATED_PERMEABILITY = {
     waterDegassed: null,
     temperature: null,
     maximumGradient: null,
+    ringWaterRepellent: null,
+    waterContentAfterwards: null,
+    materialIrregularity: [],
     saturatedPermeabilityAtSpecificDensity: [],
+    saturatedPermeabilityAtSpecificLoad: [],
 };
 /**
  * Parse water content determination from XML node
@@ -235,6 +308,7 @@ function parseOrganicMatterContentDetermination(node, adapter, namespaces) {
         determinationProcedure: getText("./bhrgtcom:determinationProcedure"),
         determinationMethod: getText("./bhrgtcom:determinationMethod"),
         removedMaterial: getText("./bhrgtcom:removedMaterial"),
+        lutumCorrectionApplied: parseBoolean(getText("./bhrgtcom:lutumCorrectionApplied")),
         organicMatterContent: parseFloat(getText("./bhrgtcom:organicMatterContent")),
     };
 }
@@ -259,6 +333,7 @@ function parseVolumetricMassDensityOfSolidsDetermination(node, adapter, namespac
         determinationProcedure: getText("./bhrgtcom:determinationProcedure"),
         determinationMethod: getText("./bhrgtcom:determinationMethod"),
         liquidUsed: getText("./bhrgtcom:usedMedium"),
+        sampleContainerVolume: getText("./bhrgtcom:sampleContainerVolume"),
         volumetricMassDensityOfSolids: parseFloat(getText("./bhrgtcom:volumetricMassDensitySolids")),
     };
 }
@@ -274,7 +349,39 @@ function parseParticleSizeDistributionDetermination(node, adapter, namespaces) {
     const standardNode = basicDistNode
         ? findChildElement(basicDistNode, "./bhrgtcom:standardDistributionFractionLarger63um", adapter, namespaces)
         : null;
+    // Coarser <63μm resolution — an alternative to detailedDistributionFractionSmaller63um.
+    // A sample carries one or the other; the shared 0-2/32-50/50-63 buckets fall back to this.
+    const standardSmallerNode = basicDistNode
+        ? findChildElement(basicDistNode, "./bhrgtcom:standardDistributionFractionSmaller63um", adapter, namespaces)
+        : null;
+    const standardSmallerBase = "./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:standardDistributionFractionSmaller63um";
+    // Finer >63μm resolution — an alternative to standardDistributionFractionLarger63um.
+    const detailedLargerNode = basicDistNode
+        ? findChildElement(basicDistNode, "./bhrgtcom:detailedDistributionFractionLarger63um", adapter, namespaces)
+        : null;
+    const detailedLargerBase = "./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:detailedDistributionFractionLarger63um";
+    const fracDL = (qname) => detailedLargerNode ? parseFloat(getText(`${detailedLargerBase}/${qname}`)) : null;
     return {
+        usedOpticalModel: getText("./bhrgtcom:usedOpticalModel"),
+        fraction63to75um: fracDL("bhrgtcom:fraction63to75um"),
+        fraction75to90um: fracDL("bhrgtcom:fraction75to90um"),
+        fraction90to106um: fracDL("bhrgtcom:fraction90to106um"),
+        fraction106to125um: fracDL("bhrgtcom:fraction106to125um"),
+        fraction125to150um: fracDL("bhrgtcom:fraction125to150um"),
+        fraction150to180um: fracDL("bhrgtcom:fraction150to180um"),
+        fraction180to212um: fracDL("bhrgtcom:fraction180to212um"),
+        fraction212to250um: fracDL("bhrgtcom:fraction212to250um"),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fraction4to5_6mm: fracDL("bhrgtcom:fraction4to5_6mm"),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fraction5_6to8mm: fracDL("bhrgtcom:fraction5_6to8mm"),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fraction8to11_2mm: fracDL("bhrgtcom:fraction8to11_2mm"),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fraction11_2to16mm: fracDL("bhrgtcom:fraction11_2to16mm"),
+        fraction16to20mm: fracDL("bhrgtcom:fraction16to20mm"),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fraction20to31_5mm: fracDL("bhrgtcom:fraction20to31_5mm"),
         determinationProcedure: getText("./bhrgtcom:determinationProcedure"),
         determinationMethod: getText("./bhrgtcom:determinationMethod"),
         fractionDistribution: getText("./bhrgtcom:fractionDistribution"),
@@ -292,6 +399,11 @@ function parseParticleSizeDistributionDetermination(node, adapter, namespaces) {
         // Detailed distribution < 63μm
         fraction0to2um: detailedNode
             ? parseFloat(getText("./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:detailedDistributionFractionSmaller63um/bhrgtcom:fraction0to2um"))
+            : standardSmallerNode
+                ? parseFloat(getText(`${standardSmallerBase}/bhrgtcom:fraction0to2um`))
+                : null,
+        fraction2to32um: standardSmallerNode
+            ? parseFloat(getText(`${standardSmallerBase}/bhrgtcom:fraction2to32um`))
             : null,
         fraction2to4um: detailedNode
             ? parseFloat(getText("./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:detailedDistributionFractionSmaller63um/bhrgtcom:fraction2to4um"))
@@ -307,10 +419,14 @@ function parseParticleSizeDistributionDetermination(node, adapter, namespaces) {
             : null,
         fraction32to50um: detailedNode
             ? parseFloat(getText("./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:detailedDistributionFractionSmaller63um/bhrgtcom:fraction32to50um"))
-            : null,
+            : standardSmallerNode
+                ? parseFloat(getText(`${standardSmallerBase}/bhrgtcom:fraction32to50um`))
+                : null,
         fraction50to63um: detailedNode
             ? parseFloat(getText("./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:detailedDistributionFractionSmaller63um/bhrgtcom:fraction50to63um"))
-            : null,
+            : standardSmallerNode
+                ? parseFloat(getText(`${standardSmallerBase}/bhrgtcom:fraction50to63um`))
+                : null,
         // Standard distribution > 63μm
         fraction63to90um: standardNode
             ? parseFloat(getText("./bhrgtcom:basicParticleSizeDistribution/bhrgtcom:standardDistributionFractionLarger63um/bhrgtcom:fraction63to90um"))
@@ -376,8 +492,9 @@ function parseConsistencyLimitsDetermination(node, adapter, namespaces) {
     const plasticityAtSpecificWaterContent = extractArray(determinationNode, "./bhrgtcom:plasticityAtSpecificWaterContent", (_pNode, getPlasticityText) => {
         const waterContent = parseFloat(getPlasticityText("./bhrgtcom:waterContent"));
         const numberOfFalls = parseInt(getPlasticityText("./bhrgtcom:numberOfFalls") ?? "0", 10);
+        const penetrationDepth = parseFloat(getPlasticityText("./bhrgtcom:penetrationDepth"));
         return waterContent !== null && !isNaN(numberOfFalls)
-            ? { waterContent, numberOfFalls }
+            ? { waterContent, numberOfFalls, penetrationDepth }
             : null;
     }, adapter, namespaces);
     return {
@@ -386,6 +503,7 @@ function parseConsistencyLimitsDetermination(node, adapter, namespaces) {
         fractionLarger500um: parseFloat(getText("./bhrgtcom:fractionLarger500um")),
         usedMedium: getText("./bhrgtcom:usedMedium"),
         performanceIrregularity: getText("./bhrgtcom:performanceIrregularity"),
+        conusType: getText("./bhrgtcom:conusType"),
         liquidLimit: parseFloat(getText("./bhrgtcom:liquidLimit")),
         plasticLimit: parseFloat(getText("./bhrgtcom:plasticLimit")),
         plasticityIndex: parseFloat(getText("./bhrgtcom:plasticityIndex")),
@@ -411,6 +529,26 @@ function parseSettlementCharacteristicsDetermination(node, adapter, namespaces)
                 ? { time, height }
                 : null;
         });
+        // Optional alternative time-series: stress/strain during settlement (5 columns)
+        const stressChangeNode = findChildElement(stepNode, "./bhrgtcom:stressChangeDuringSettlement/bhrgtcom:values", adapter, namespaces);
+        const stressChangeDuringSettlement = stressChangeNode
+            ? parseCSVRows(stressChangeNode.textContent, (columns) => {
+                if (columns.length < 5) {
+                    return null;
+                }
+                const elapsedTime = parseFloat(columns[0]);
+                const verticalStrain = parseFloat(columns[1]);
+                return elapsedTime !== null && verticalStrain !== null
+                    ? {
+                        elapsedTime,
+                        verticalStrain,
+                        excessPoreWaterPressure: parseFloat(columns[2]),
+                        verticalEffectiveStress: parseFloat(columns[3]),
+                        horizontalEffectiveStress: parseFloat(columns[4]),
+                    }
+                    : null;
+            })
+            : undefined;
         return {
             stepNumber,
             wetPerformed: parseBoolean(getStepText("./bhrgtcom:wetPerformed")),
@@ -419,8 +557,25 @@ function parseSettlementCharacteristicsDetermination(node, adapter, namespaces)
             stepType: getStepText("./bhrgtcom:stepType"),
             verticalStress: parseFloat(getStepText("./bhrgtcom:verticalStress")),
             heightChangeDuringSettlement,
+            ...(stressChangeDuringSettlement ? { stressChangeDuringSettlement } : {}),
         };
     }, adapter, namespaces);
+    // Optional saturation stage performed before compression
+    const saturationNode = findChildElement(determinationNode, "./bhrgtcom:saturationStageAtCompression", adapter, namespaces);
+    let saturationStageAtCompression;
+    if (saturationNode) {
+        const getSatText = createXPathTextGetter(saturationNode, adapter, namespaces);
+        saturationStageAtCompression = {
+            porousDiscWet: parseBoolean(getSatText("./bhrgtcom:porousDiscWet")),
+            usedMedium: getSatText("./bhrgtcom:usedMedium"),
+            backPressure: parseFloat(getSatText("./bhrgtcom:backPressure")),
+            constantHeight: parseBoolean(getSatText("./bhrgtcom:constantHeight")),
+            specimenHeightAfterwards: parseFloat(getSatText("./bhrgtcom:specimenHeightAfterwards")),
+            disturbanceInduced: parseBoolean(getSatText("./bhrgtcom:disturbanceInduced")),
+            maximumStressDifference: parseFloat(getSatText("./bhrgtcom:maximumStressDifference")),
+            maximumStrain: parseFloat(getSatText("./bhrgtcom:maximumStrain")),
+        };
+    }
     return {
         determinationProcedure: getText("./bhrgtcom:determinationProcedure"),
         determinationMethod: getText("./bhrgtcom:determinationMethod"),
@@ -432,6 +587,7 @@ function parseSettlementCharacteristicsDetermination(node, adapter, namespaces)
         apparatusDeformationApplied: parseBoolean(getText("./bhrgtcom:apparatusDeformationApplied")),
         bearingFrictionCorrectionApplied: parseBoolean(getText("./bhrgtcom:bearingFrictionCorrectionApplied")),
         irregularResult: parseBoolean(getText("./bhrgtcom:irregularResult")),
+        ...(saturationStageAtCompression ? { saturationStageAtCompression } : {}),
         determinationSteps,
     };
 }
@@ -451,6 +607,18 @@ function parseSaturatedPermeabilityDetermination(node, adapter, namespaces) {
             ? { dryVolumetricMassDensity, saturatedPermeability }
             : null;
     }, adapter, namespaces);
+    const saturatedPermeabilityAtSpecificLoad = extractArray(determinationNode, "./bhrgtcom:saturatedPermeabilityAtSpecificLoad", (_loadNode, getLoadText) => {
+        const load = parseFloat(getLoadText("./bhrgtcom:load"));
+        const saturatedPermeability = parseFloat(getLoadText("./bhrgtcom:saturatedPermeability"));
+        return load !== null || saturatedPermeability !== null
+            ? { load, saturatedPermeability }
+            : null;
+    }, adapter, namespaces);
+    const nsResolver = createNamespaceResolver(namespaces);
+    const materialIrregularity = adapter
+        .evaluateXPathAll(determinationNode, "./bhrgtcom:materialIrregularity", nsResolver)
+        .map((n) => n.textContent?.trim() ?? "")
+        .filter((s) => s !== "");
     return {
         determinationProcedure: getText("./bhrgtcom:determinationProcedure"),
         determinationMethod: getText("./bhrgtcom:determinationMethod"),
@@ -462,7 +630,11 @@ function parseSaturatedPermeabilityDetermination(node, adapter, namespaces) {
         waterDegassed: parseBoolean(getText("./bhrgtcom:waterDegassed")),
         temperature: parseFloat(getText("./bhrgtcom:temperature")),
         maximumGradient: parseFloat(getText("./bhrgtcom:maximumGradient")),
+        ringWaterRepellent: getText("./bhrgtcom:ringWaterRepellent"),
+        waterContentAfterwards: parseFloat(getText("./bhrgtcom:waterContentAfterwards")),
+        materialIrregularity,
         saturatedPermeabilityAtSpecificDensity,
+        saturatedPermeabilityAtSpecificLoad,
     };
 }
 /**
@@ -504,6 +676,15 @@ function parseShearStressChangeDuringLoadingDeterminations(node, adapter, namesp
             cellDeformationApplied: parseBoolean(getText("./bhrgtcom:cellDeformationApplied")),
             stopCriterion: getText("./bhrgtcom:stopCriterion"),
         };
+        // Parse made specimen (optional nested object; only for remoulded specimens)
+        const madeSpecimenNode = findChildElement(actualDeterminationNode, "./bhrgtcom:madeSpecimenForLoading", adapter, namespaces);
+        if (madeSpecimenNode) {
+            const getMadeText = createXPathTextGetter(madeSpecimenNode, adapter, namespaces);
+            determination.madeSpecimenForLoading = {
+                makingMethod: getMadeText("./bhrgtcom:makingMethod"),
+                dryVolumetricMassDensity: parseFloat(getMadeText("./bhrgtcom:dryVolumetricMassDensity")),
+            };
+        }
         // Parse membrane correction (optional nested object)
         const membraneCorrectionNode = findChildElement(actualDeterminationNode, "./bhrgtcom:membraneCorrection", adapter, namespaces);
         if (membraneCorrectionNode) {
@@ -538,6 +719,7 @@ function parseShearStressChangeDuringLoadingDeterminations(node, adapter, namesp
                 effectivePressure: parseFloat(getSatText("./bhrgtcom:effectivePressure")),
                 skemptonBCoefficient: parseFloat(getSatText("./bhrgtcom:skemptonB_Coefficient")),
                 disturbanceInduced: parseBoolean(getSatText("./bhrgtcom:disturbanceInduced")),
+                stressDifference: parseFloat(getSatText("./bhrgtcom:stressDifference")),
             };
         }
         // Parse consolidation stage (optional nested object with time-series data)
@@ -618,6 +800,8 @@ function parseMaximumUndrainedShearStrengthDetermination(node, adapter, namespac
         verticallyDetermined: parseBoolean(getText("./bhrgtcom:verticallyDetermined")),
         sampleMoistness: getText("./bhrgtcom:sampleMoistness"),
         maximumUndrainedShearStrength: parseFloat(getText("./bhrgtcom:maximumUndrainedShearStrength")),
+        lowestMaximumUndrainedShearStrength: parseFloat(getText("./bhrgtcom:lowestMaximumUndrainedShearStrength")),
+        highestMaximumUndrainedShearStrength: parseFloat(getText("./bhrgtcom:highestMaximumUndrainedShearStrength")),
     };
 }
 /**
@@ -798,7 +982,7 @@ const DETERMINATION_CONFIGS = [
  * Extracts laboratory analysis data including all investigated intervals
  * and their determination results.
  *
- * @param value - Not used (we work with the node directly)
+ * @param _value - Not used (we work with the node directly)
  * @param context - Resolver context containing the XML node and adapter
  * @returns BoreholeSampleAnalysis object or undefined if not present
  */
@@ -813,16 +997,7 @@ export function processBoreholeSampleAnalysis(_value, context) {
     // Extract analysis metadata
     const analysisReportDateNode = adapter.evaluateXPath(analysisNode, "./bhrgtcom:analysisReportDate", nsResolver);
     const analysisProcedureNode = adapter.evaluateXPath(analysisNode, "./bhrgtcom:analysisProcedure", nsResolver);
-    let analysisReportDate = null;
-    if (analysisReportDateNode?.textContent) {
-        const dateStr = analysisReportDateNode.textContent.trim();
-        try {
-            analysisReportDate = new Date(dateStr);
-        }
-        catch {
-            analysisReportDate = null;
-        }
-    }
+    const analysisReportDate = parseDate(analysisReportDateNode?.textContent);
     const analysisProcedure = analysisProcedureNode?.textContent?.trim() ?? null;
     // Find all investigated intervals
     const intervalNodes = adapter.evaluateXPathAll(analysisNode, "./bhrgtcom:investigatedInterval", nsResolver);
@@ -924,7 +1099,7 @@ export function processSampledIntervals(_value, context) {
             preTreatment: getText("./bhrgtcom:preTreatment"),
             samplingMethod: getText("./bhrgtcom:samplingMethod"),
             samplingQuality: getText("./bhrgtcom:samplingQuality"),
-            orientatedSampled: parseJaNee(getText("./bhrgtcom:orientatedSampled")),
+            orientatedSampled: parseBoolean(getText("./bhrgtcom:orientatedSampled")),
         };
         // Check for nested sampler element
         const samplerNode = adapter.evaluateXPath(intervalNode, "./bhrgtcom:sampler", nsResolver);
@@ -936,15 +1111,26 @@ export function processSampledIntervals(_value, context) {
                 sampleContainerLength: parseFloat(getSamplerText("./bhrgtcom:sampleContainerLength")),
                 cuttingShoeInsideDiameter: parseFloat(getSamplerText("./bhrgtcom:cuttingShoeInsideDiameter")),
                 cuttingShoeOutsideDiameter: parseFloat(getSamplerText("./bhrgtcom:cuttingShoeOutsideDiameter")),
-                stockingUsed: parseJaNee(getSamplerText("./bhrgtcom:stockingUsed")),
-                rightAngledCuttingShoe: parseJaNee(getSamplerText("./bhrgtcom:rightAngledCuttingShoe")),
+                stockingUsed: parseBoolean(getSamplerText("./bhrgtcom:stockingUsed")),
+                rightAngledCuttingShoe: parseBoolean(getSamplerText("./bhrgtcom:rightAngledCuttingShoe")),
                 taperAngle: parseFloat(getSamplerText("./bhrgtcom:taperAngle")),
-                lubricationFluidUsed: parseJaNee(getSamplerText("./bhrgtcom:lubricationFluidUsed")),
-                coreCatcherPresent: parseJaNee(getSamplerText("./bhrgtcom:coreCatcherPresent")),
-                pistonPresent: parseJaNee(getSamplerText("./bhrgtcom:pistonPresent")),
+                lubricationFluidUsed: parseBoolean(getSamplerText("./bhrgtcom:lubricationFluidUsed")),
+                coreCatcherPresent: parseBoolean(getSamplerText("./bhrgtcom:coreCatcherPresent")),
+                pistonPresent: parseBoolean(getSamplerText("./bhrgtcom:pistonPresent")),
             };
             interval.sampler = sampler;
         }
+        // Check for nested coreRecovery element (rock coring)
+        const coreRecoveryNode = adapter.evaluateXPath(intervalNode, "./bhrgtcom:coreRecovery", nsResolver);
+        if (coreRecoveryNode) {
+            const getCoreText = createXPathTextGetter(coreRecoveryNode, adapter, namespaces);
+            interval.coreRecovery = {
+                totalCoreRecovery: parseFloat(getCoreText("./bhrgtcom:totalCoreRecovery")),
+                solidCoreRecovery: parseFloat(getCoreText("./bhrgtcom:solidCoreRecovery")),
+                rockQualityDesignation: parseFloat(getCoreText("./bhrgtcom:rockQualityDesignation")),
+                fieldDetermined: parseBoolean(getCoreText("./bhrgtcom:fieldDetermined")),
+            };
+        }
         intervals.push(interval);
     }
     return intervals;
@@ -970,14 +1156,88 @@ export function processCompletedIntervals(_value, context) {
         intervals.push({
             beginDepth,
             endDepth,
-            permanentCasingPresent: parseJaNee(getText("./bhrgtcom:permanentCasingPresent")),
+            permanentCasingPresent: parseBoolean(getText("./bhrgtcom:permanentCasingPresent")),
+            diameterPermanentCasing: parseFloat(getText("./bhrgtcom:diameterPermanentCasing")),
+            materialPermanentCasing: getText("./bhrgtcom:materialPermanentCasing"),
             backfillMaterial: getText("./bhrgtcom:backfillMaterial"),
-            backfillMaterialWashed: parseJaNee(getText("./bhrgtcom:backfillMaterialWashed")),
-            backfillMaterialCertified: parseJaNee(getText("./bhrgtcom:backfillMaterialCertified")),
+            backfillMaterialWashed: parseBoolean(getText("./bhrgtcom:backfillMaterialWashed")),
+            backfillMaterialCertified: parseBoolean(getText("./bhrgtcom:backfillMaterialCertified")),
         });
     }
     return intervals;
 }
+/**
+ * Process excavated layers from boring element
+ *
+ * Layers removed by excavation before/during boring.
+ */
+export function processExcavatedLayers(_value, context) {
+    const { element, adapter, namespaces } = context;
+    const nsResolver = createNamespaceResolver(namespaces);
+    const layerNodes = adapter.evaluateXPathAll(element, "./dsbhrgt:boring/bhrgtcom:excavatedLayer", nsResolver);
+    const layers = [];
+    for (const layerNode of layerNodes) {
+        const getText = createXPathTextGetter(layerNode, adapter, namespaces);
+        const upperBoundary = parseFloat(getText("./bhrgtcom:upperBoundary"));
+        const lowerBoundary = parseFloat(getText("./bhrgtcom:lowerBoundary"));
+        if (upperBoundary === null || lowerBoundary === null) {
+            continue;
+        }
+        layers.push({
+            upperBoundary,
+            lowerBoundary,
+            excavatedMaterial: getText("./bhrgtcom:excavatedMaterial"),
+        });
+    }
+    return layers;
+}
+/**
+ * Process boring velocity profile from boring element
+ *
+ * Series of (elapsed time, depth) points describing drilling progress.
+ */
+export function processBoringVelocity(_value, context) {
+    const { element, adapter, namespaces } = context;
+    const nsResolver = createNamespaceResolver(namespaces);
+    const velocityNodes = adapter.evaluateXPathAll(element, "./dsbhrgt:boring/bhrgtcom:boringVelocity", nsResolver);
+    return velocityNodes.map((node) => {
+        const getText = createXPathTextGetter(node, adapter, namespaces);
+        return {
+            elapsedTime: parseFloat(getText("./bhrgtcom:elapsedTime")),
+            depth: parseFloat(getText("./bhrgtcom:depth")),
+        };
+    });
+}
+/**
+ * Process fluid mud layer from document element
+ *
+ * Single optional fluid mud (slib) layer recorded at the borehole.
+ */
+export function processFluidMudLayer(_value, context) {
+    const { element, adapter, namespaces } = context;
+    const nsResolver = createNamespaceResolver(namespaces);
+    const node = adapter.evaluateXPath(element, "./dsbhrgt:fluidMudLayer", nsResolver);
+    if (!node) {
+        return undefined;
+    }
+    const getText = createXPathTextGetter(node, adapter, namespaces);
+    return {
+        thickness: parseFloat(getText("./bhrgtcom:thickness")),
+        colour: getText("./bhrgtcom:colour"),
+        upperBoundaryPositioningMethod: getText("./bhrgtcom:upperBoundaryPositioningMethod"),
+        lowerBoundaryPositioningMethod: getText("./bhrgtcom:lowerBoundaryPositioningMethod"),
+    };
+}
+/**
+ * Resolve an organisation identifier (KvK number, or European company
+ * registration number as a fallback) from an organisation element.
+ */
+export function resolveOrganisationId(_value, context) {
+    const { node, adapter, namespaces } = context;
+    const getText = createXPathTextGetter(node, adapter, namespaces);
+    return (getText("./brocom:chamberOfCommerceNumber") ??
+        getText("./brocom:europeanCompanyRegistrationNumber"));
+}
 /**
  * Process not described intervals from boreholeSampleDescription element
  *
@@ -1005,34 +1265,43 @@ export function processNotDescribedIntervals(_value, context) {
     return intervals;
 }
 /**
- * Process registration history from document element
+ * Process post-sedimentary discontinuities from the descriptive borehole log
  *
- * Extracts BRO registration history information.
+ * Fractures/fault planes crossing described intervals (e.g. in rock).
  */
-export function processRegistrationHistory(_value, context) {
+export function processPostSedimentaryDiscontinuities(_value, context) {
     const { element, adapter, namespaces } = context;
     const nsResolver = createNamespaceResolver(namespaces);
-    // Find registrationHistory element (in default namespace dsbhrgt)
-    const historyNode = adapter.evaluateXPath(element, "./dsbhrgt:registrationHistory", nsResolver);
-    if (!historyNode) {
-        return null;
+    const nodes = adapter.evaluateXPathAll(element, "./dsbhrgt:boreholeSampleDescription/bhrgtcom:descriptiveBoreholeLog/bhrgtcom:postSedimentaryDiscontinuity", nsResolver);
+    const out = [];
+    for (const node of nodes) {
+        const getText = createXPathTextGetter(node, adapter, namespaces);
+        const beginDepth = parseFloat(getText("./bhrgtcom:beginDepth"));
+        const endDepth = parseFloat(getText("./bhrgtcom:endDepth"));
+        if (beginDepth === null || endDepth === null) {
+            continue;
+        }
+        out.push({
+            beginDepth,
+            endDepth,
+            inRock: getText("./bhrgtcom:inRock"),
+            discontinuityType: getText("./bhrgtcom:discontinuityType"),
+            compositeDiscontinuity: getText("./bhrgtcom:compositeDiscontinuity"),
+            spacing: parseFloat(getText("./bhrgtcom:spacing")),
+            smooth: getText("./bhrgtcom:smooth"),
+            apertureClass: getText("./bhrgtcom:apertureClass"),
+            infillMaterial: getText("./bhrgtcom:infillMaterial"),
+        });
     }
-    const getText = createXPathTextGetter(historyNode, adapter, namespaces);
-    // Parse dates
-    const objectRegistrationTimeStr = getText("./brocom:objectRegistrationTime");
-    const registrationCompletionTimeStr = getText("./brocom:registrationCompletionTime");
-    return {
-        objectRegistrationTime: objectRegistrationTimeStr ? new Date(objectRegistrationTimeStr) : null,
-        registrationStatus: getText("./brocom:registrationStatus"),
-        registrationCompletionTime: registrationCompletionTimeStr
-            ? new Date(registrationCompletionTimeStr)
-            : null,
-        corrected: parseJaNee(getText("./brocom:corrected")),
-        underReview: parseJaNee(getText("./brocom:underReview")),
-        deregistered: parseJaNee(getText("./brocom:deregistered")),
-        reregistered: parseJaNee(getText("./brocom:reregistered")),
-    };
+    return out;
 }
+/**
+ * Process registration history from document element
+ *
+ * Extracts BRO registration history information.
+ */
+// Registration history is parsed by the shared processRegistrationHistory in
+// bore-resolver-utils (identical across CPT/BHR-GT/BHR-G).
 /**
  * Process report history from document element
  *
@@ -1048,22 +1317,22 @@ export function processReportHistory(_value, context) {
     }
     const getText = createXPathTextGetter(historyNode, adapter, namespaces);
     // Parse dates - these elements are in the default namespace (no prefix)
-    const reportStartDateStr = getText("./dsbhrgt:reportStartDate/brocom:date");
-    const reportEndDateStr = getText("./dsbhrgt:reportEndDate/brocom:date");
+    const reportStartDateStr = getText("./dsbhrgt:reportStartDate");
+    const reportEndDateStr = getText("./dsbhrgt:reportEndDate");
     // Find intermediate events (in default namespace)
     const eventNodes = adapter.evaluateXPathAll(historyNode, "./dsbhrgt:intermediateEvent", nsResolver);
     const intermediateEvents = [];
     for (const eventNode of eventNodes) {
         const getEventText = createXPathTextGetter(eventNode, adapter, namespaces);
-        const eventDateStr = getEventText("./dsbhrgt:eventDate/brocom:date");
+        const eventDateStr = getEventText("./dsbhrgt:eventDate");
         intermediateEvents.push({
             eventName: getEventText("./dsbhrgt:eventName"),
-            eventDate: eventDateStr ? new Date(eventDateStr) : null,
+            eventDate: parseDate(eventDateStr),
         });
     }
     return {
-        reportStartDate: reportStartDateStr ? new Date(reportStartDateStr) : null,
-        reportEndDate: reportEndDateStr ? new Date(reportEndDateStr) : null,
+        reportStartDate: parseDate(reportStartDateStr),
+        reportEndDate: parseDate(reportEndDateStr),
         intermediateEvents,
     };
 }