@geotechcli/core 0.4.53 → 0.4.55

package/dist/report/integrated-review-model.js

@@ -0,0 +1,649 @@
+import { DEFAULT_LLM_MODEL, DEFAULT_LLM_VISION_MODEL } from '../meta/index.js';
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value)))]
+        .filter(Boolean);
+}
+function compactLabel(value, maxLength = 28) {
+    const normalized = (value ?? '').replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function compactSummary(value, maxLength = 520) {
+    const normalized = (value ?? '').replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function groundModelMaterialKey(description) {
+    const text = description.toLowerCase();
+    if (/peat|organic|top\s*soil|topsoil/.test(text))
+        return 'organic';
+    if (/bedrock|fresh\s+rock|strong\s+(?:shale|sandstone|siltstone|gneiss|rock)/.test(text))
+        return 'bedrock';
+    if (/weathered|fractured|rock|shale|sandstone|gneiss/.test(text))
+        return 'weathered-rock';
+    if (/gravel|\bgm\b|\bgp\b|\bgw\b/.test(text))
+        return 'gravel';
+    if (/sand|\bsm\b|\bsp\b|\bsw\b|\bsc\b/.test(text))
+        return 'sand';
+    if (/clay|\bci\b|\bcl\b|\bch\b/.test(text))
+        return 'clay';
+    if (/silt|\bml\b|\bmh\b/.test(text))
+        return 'silt';
+    if (/fill|made\s+ground|debris/.test(text))
+        return 'fill';
+    return 'mixed';
+}
+function stratumTopDepth(stratum, index, sorted) {
+    if (finiteNumber(stratum.topDepth))
+        return Math.max(0, stratum.topDepth);
+    if (index === 0)
+        return 0;
+    return sorted[index - 1]?.bottomDepth ?? 0;
+}
+function stratumBottomDepth(stratum, index, sorted, maxDepth) {
+    if (finiteNumber(stratum.bottomDepth))
+        return Math.max(0, stratum.bottomDepth);
+    const nextTop = sorted[index + 1]?.topDepth;
+    if (finiteNumber(nextTop))
+        return Math.max(0, nextTop);
+    return maxDepth;
+}
+export function normalizeIntegratedConfidence(value) {
+    if (!Number.isFinite(value ?? NaN))
+        return 0.5;
+    return Math.max(0, Math.min(1, value > 1 ? value / 100 : value));
+}
+export function integratedPercent(value) {
+    return `${Math.round(normalizeIntegratedConfidence(value) * 100)}%`;
+}
+function integratedStatus(confidence, warnings = []) {
+    return normalizeIntegratedConfidence(confidence) >= 0.78 && warnings.length === 0
+        ? 'accepted'
+        : 'review_recommended';
+}
+function integratedClass(description) {
+    const key = groundModelMaterialKey(description);
+    if (key === 'fill' || key === 'clay' || key === 'silt' || key === 'sand' || key === 'gravel')
+        return key;
+    if (key === 'weathered-rock' || key === 'bedrock')
+        return 'rock';
+    return 'mixed';
+}
+function integratedClassLabel(className) {
+    switch (className) {
+        case 'fill': return 'Fill';
+        case 'clay': return 'Clay';
+        case 'silt': return 'Silt';
+        case 'sand': return 'Sand';
+        case 'gravel': return 'Gravel';
+        case 'rock': return 'Rock';
+        default: return 'Mixed';
+    }
+}
+function shortIntegratedLabel(value, fallback) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return fallback;
+    const material = integratedClassLabel(integratedClass(normalized));
+    return material === 'Mixed' ? compactLabel(normalized, 18) : material;
+}
+function evidenceLookup(model) {
+    return new Map((model?.evidence ?? []).map((entry) => [entry.id, entry]));
+}
+function pagesForEvidenceIds(evidenceById, evidenceIds) {
+    return [...new Set(evidenceIds
+            .map((id) => evidenceById.get(id)?.location.pageNumber)
+            .filter((page) => typeof page === 'number' && Number.isInteger(page) && page > 0))]
+        .sort((left, right) => left - right);
+}
+export function sourcePagesLabel(pages) {
+    return pages.length > 0 ? `p${pages.join(', ')}` : 'source evidence';
+}
+function positiveDimension(value) {
+    return Number.isFinite(value ?? NaN) && (value ?? 0) > 0 ? value : null;
+}
+function inferredPageDimension(page, axis) {
+    const explicit = positiveDimension(axis === 'width' ? page.width : page.height);
+    if (explicit != null) {
+        return explicit;
+    }
+    const elementDimension = page.elements
+        .map((element) => axis === 'width' ? element.width : element.height)
+        .find((value) => positiveDimension(value) != null);
+    if (elementDimension != null) {
+        return elementDimension;
+    }
+    const coordinateIndex = axis === 'width' ? 2 : 3;
+    const maxCoordinate = Math.max(0, ...page.elements
+        .map((element) => element.bbox2d?.[coordinateIndex])
+        .filter((value) => Number.isFinite(value ?? NaN) && (value ?? 0) > 0));
+    return maxCoordinate > 0 ? maxCoordinate : axis === 'width' ? 1000 : 1414;
+}
+function clampCoordinate(value, max) {
+    return Math.max(0, Math.min(max, Number.isFinite(value) ? value : 0));
+}
+function bboxLooksLikeRatio(bbox) {
+    return bbox.every((value) => Number.isFinite(value) && value >= 0 && value <= 1);
+}
+function normalizeLayoutBbox(bbox, width, height, units) {
+    if (!bbox) {
+        return null;
+    }
+    const ratioUnits = units === 'ratio' || (units !== 'page' && bboxLooksLikeRatio(bbox));
+    const scaled = ratioUnits
+        ? [bbox[0] * width, bbox[1] * height, bbox[2] * width, bbox[3] * height]
+        : bbox;
+    const x1 = clampCoordinate(Math.min(scaled[0], scaled[2]), width);
+    const y1 = clampCoordinate(Math.min(scaled[1], scaled[3]), height);
+    const x2 = clampCoordinate(Math.max(scaled[0], scaled[2]), width);
+    const y2 = clampCoordinate(Math.max(scaled[1], scaled[3]), height);
+    const minSpan = ratioUnits && width <= 1 && height <= 1 ? 0.001 : 2;
+    if (x2 - x1 < minSpan || y2 - y1 < minSpan) {
+        return null;
+    }
+    return [x1, y1, x2, y2];
+}
+function inferSourceRegionType(label, content) {
+    const text = `${label} ${content}`.toLowerCase();
+    if (/\bspt\b|standard\s+penetration|n[-\s]?value|blows\s*\/?\s*(?:300\s*mm|ft)/.test(text)) {
+        return 'spt';
+    }
+    if (/ground\s*water|groundwater|water\s+table|gwl/.test(text)) {
+        return 'water';
+    }
+    if (/easting|northing|coordinate|latitude|longitude|\be\s*[:=]?\s*\d|\bn\s*[:=]?\s*\d/.test(text)) {
+        return 'coordinates';
+    }
+    if (/total\s+depth|final\s+depth|termination|terminated|depth\s+of\s+bore/.test(text)) {
+        return 'totalDepth';
+    }
+    if (/moisture|water\s*content|liquid\s*limit|plasticity|cohesion|friction|unit\s*weight|density|ucs|rqd|rmr|permeability/.test(text)) {
+        return 'parameter';
+    }
+    if (/strata|lithology|description|sample|clay|silt|sand|gravel|rock|fill|made\s+ground/.test(text)) {
+        return 'strata';
+    }
+    if (/bore\s*hole|borehole|project|location|client|sheet|hole\s+no/.test(text)) {
+        return 'header';
+    }
+    if (label === 'table')
+        return 'table';
+    if (label === 'image')
+        return 'image';
+    if (label === 'formula')
+        return 'formula';
+    if (label === 'text')
+        return 'text';
+    return 'unknown';
+}
+function findLayoutRegionLink(links, pageNumber, elementIndex, elementOrdinal, content) {
+    const normalizedContent = content.toLowerCase();
+    return links.find((link) => {
+        if (link.pageNumber !== pageNumber) {
+            return false;
+        }
+        if (link.elementOrdinal != null) {
+            return link.elementOrdinal === elementOrdinal;
+        }
+        if (link.elementIndex != null) {
+            return link.elementIndex === elementIndex;
+        }
+        if (link.contentIncludes?.trim()) {
+            return normalizedContent.includes(link.contentIncludes.trim().toLowerCase());
+        }
+        return false;
+    });
+}
+export function buildIntegratedSourcePagesFromLayout(pages, options = {}) {
+    const method = options.method ?? 'glm-ocr-layout';
+    const links = options.links ?? [];
+    return pages.flatMap((page) => {
+        const width = inferredPageDimension(page, 'width');
+        const height = inferredPageDimension(page, 'height');
+        const regions = page.elements.flatMap((element, index) => {
+            const bbox = normalizeLayoutBbox(element.bbox2d, width, height);
+            if (!bbox) {
+                return [];
+            }
+            const link = findLayoutRegionLink(links, page.pageNumber, element.index, index, element.content);
+            const confidence = normalizeIntegratedConfidence(link?.confidence ?? 0.72);
+            const regionIndex = index + 1;
+            return [{
+                    id: `layout-p${page.pageNumber}-r${regionIndex}`,
+                    evidenceId: link?.evidenceId ?? `layout-p${page.pageNumber}-r${regionIndex}`,
+                    pageNumber: page.pageNumber,
+                    type: link?.type ?? inferSourceRegionType(element.label, element.content),
+                    label: compactLabel(link?.label ?? element.label, 42),
+                    text: compactSummary(element.content, 240),
+                    bbox,
+                    confidence,
+                    method: link?.method ?? method,
+                    status: link?.status ?? (confidence >= 0.78 ? 'accepted' : 'review_recommended'),
+                }];
+        });
+        if (regions.length === 0) {
+            return [];
+        }
+        return [{
+                pageNumber: page.pageNumber,
+                width,
+                height,
+                sourcePath: options.sourcePath ?? `page-${page.pageNumber}`,
+                method,
+                regions,
+            }];
+    });
+}
+export function buildIntegratedSourcePagesFromEvidence(evidenceRefs = [], sourcePathFallback = 'source evidence') {
+    const grouped = new Map();
+    for (const ref of evidenceRefs) {
+        const bbox = ref.location.bbox;
+        const pageNumber = ref.location.pageNumber;
+        if (!bbox || pageNumber == null || !Number.isInteger(pageNumber) || pageNumber <= 0) {
+            continue;
+        }
+        const ratioUnits = ref.location.bboxUnits === 'ratio' || (ref.location.bboxUnits !== 'page' && bboxLooksLikeRatio(bbox));
+        const width = positiveDimension(ref.location.pageWidth)
+            ?? (ratioUnits ? 1 : Math.max(1000, bbox[0], bbox[2]));
+        const height = positiveDimension(ref.location.pageHeight)
+            ?? (ratioUnits ? 1 : Math.max(1414, bbox[1], bbox[3]));
+        const normalizedBbox = normalizeLayoutBbox(bbox, width, height, ref.location.bboxUnits);
+        if (!normalizedBbox) {
+            continue;
+        }
+        const text = compactSummary(String(ref.normalizedValue ?? ref.rawValue ?? ''), 240);
+        const region = {
+            id: `evidence-${ref.id}`,
+            evidenceId: ref.id,
+            pageNumber,
+            type: inferSourceRegionType(ref.location.layoutLabel ?? ref.sourceType, text),
+            label: compactLabel(ref.location.layoutLabel ?? ref.sourceType, 42),
+            text,
+            bbox: normalizedBbox,
+            confidence: normalizeIntegratedConfidence(ref.confidence),
+            method: ref.method,
+            status: integratedStatus(ref.confidence, ref.warnings),
+        };
+        const existing = grouped.get(pageNumber);
+        if (existing) {
+            existing.regions.push(region);
+            existing.width = Math.max(existing.width, width);
+            existing.height = Math.max(existing.height, height);
+            continue;
+        }
+        grouped.set(pageNumber, {
+            pageNumber,
+            width,
+            height,
+            sourcePath: ref.sourcePath || ref.location.filePath || sourcePathFallback,
+            method: ref.method,
+            regions: [region],
+        });
+    }
+    return [...grouped.values()].sort((left, right) => left.pageNumber - right.pageNumber);
+}
+function mergeIntegratedSourcePages(...pageSets) {
+    const grouped = new Map();
+    for (const pages of pageSets) {
+        for (const rawPage of pages) {
+            const page = sanitizeIntegratedSourcePage(rawPage);
+            if (!page) {
+                continue;
+            }
+            const existing = grouped.get(page.pageNumber);
+            if (!existing) {
+                grouped.set(page.pageNumber, {
+                    ...page,
+                    regions: [...page.regions],
+                });
+                continue;
+            }
+            const seen = new Set(existing.regions.map((region) => `${region.id}:${region.evidenceId}:${region.bbox.join(',')}`));
+            for (const region of page.regions) {
+                const key = `${region.id}:${region.evidenceId}:${region.bbox.join(',')}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    existing.regions.push(region);
+                }
+            }
+            existing.width = Math.max(existing.width, page.width);
+            existing.height = Math.max(existing.height, page.height);
+            if (existing.sourcePath === 'source evidence' && page.sourcePath !== 'source evidence') {
+                existing.sourcePath = page.sourcePath;
+            }
+            if (existing.method === 'manual' && page.method !== 'manual') {
+                existing.method = page.method;
+            }
+        }
+    }
+    return [...grouped.values()].sort((left, right) => left.pageNumber - right.pageNumber);
+}
+function sanitizeIntegratedSourcePage(page) {
+    if (!Number.isInteger(page.pageNumber)
+        || page.pageNumber <= 0
+        || !Number.isFinite(page.width)
+        || !Number.isFinite(page.height)
+        || page.width <= 0
+        || page.height <= 0) {
+        return null;
+    }
+    const regions = page.regions.flatMap((region) => {
+        if (region.pageNumber !== page.pageNumber) {
+            return [];
+        }
+        const bbox = normalizeLayoutBbox(region.bbox, page.width, page.height, 'page');
+        if (!bbox) {
+            return [];
+        }
+        return [{
+                ...region,
+                bbox,
+                confidence: normalizeIntegratedConfidence(region.confidence),
+                status: region.status === 'accepted' ? 'accepted' : 'review_recommended',
+            }];
+    });
+    return regions.length > 0
+        ? {
+            ...page,
+            regions,
+        }
+        : null;
+}
+function sourceRegionPriority(region) {
+    if (region.method === 'glm-ocr-layout')
+        return 4;
+    if (region.method.includes('ocr'))
+        return 3;
+    if (region.method === 'vision')
+        return 2;
+    if (region.method === 'pdf-text')
+        return 1;
+    return 0;
+}
+function sourceRegionLookup(pages) {
+    const lookup = new Map();
+    for (const region of pages.flatMap((page) => page.regions)) {
+        const existing = lookup.get(region.evidenceId);
+        if (!existing || sourceRegionPriority(region) > sourceRegionPriority(existing)) {
+            lookup.set(region.evidenceId, region);
+        }
+    }
+    return lookup;
+}
+export function integratedBoreholeMaxDepth(borehole) {
+    return Math.max(1, borehole.totalDepth, ...borehole.strata.flatMap((stratum) => [stratum.top, stratum.base]), ...borehole.spt.map((point) => point.depth), ...borehole.groundwater.map((point) => point.depth));
+}
+export function buildIntegratedAgentReviewFromProjectSession(session) {
+    const reviewPassed = typeof session.metadata?.reviewPassed === 'boolean'
+        ? session.metadata.reviewPassed
+        : undefined;
+    const corrections = Array.isArray(session.metadata?.corrections)
+        ? session.metadata.corrections.filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+        : [];
+    const warnings = uniqueStrings([
+        reviewPassed === false ? 'Swarm reviewer did not pass the session without correction.' : null,
+        ...corrections.map((correction) => `Correction: ${correction}`),
+    ]);
+    return {
+        mode: session.mode,
+        title: session.mode === 'swarm'
+            ? 'Swarm agent review'
+            : session.mode === 'chat'
+                ? 'Chat agent review'
+                : 'Single agent review',
+        summary: compactSummary(session.answer ?? session.summary ?? session.query),
+        stepCount: session.stepCount,
+        tokens: session.tokens,
+        latencyMs: session.latencyMs,
+        warnings,
+        evidenceIds: [],
+    };
+}
+export function buildIntegratedAgentReviewFromLiveSession(mode, query, session) {
+    const answer = session.steps.find((step) => step.type === 'answer')?.content;
+    const failedTools = session.steps
+        .filter((step) => step.type === 'tool_result' && step.toolResult?.success === false)
+        .map((step) => step.toolName ? `Tool failed: ${step.toolName}` : 'Tool failed during agent review.');
+    const swarmWarnings = 'reviewPassed' in session && session.reviewPassed === false
+        ? ['Swarm reviewer did not pass the session without correction.', ...session.corrections.map((correction) => `Correction: ${correction}`)]
+        : [];
+    return {
+        mode,
+        title: mode === 'swarm'
+            ? 'Swarm agent review'
+            : mode === 'chat'
+                ? 'Chat agent review'
+                : 'Single agent review',
+        summary: compactSummary(answer ?? query),
+        stepCount: session.steps.length,
+        tokens: session.totalTokens,
+        latencyMs: session.totalLatencyMs,
+        warnings: uniqueStrings([...failedTools, ...swarmWarnings]),
+        evidenceIds: [],
+    };
+}
+function buildIntegratedBoreholesFromGroundModel(model, regionByEvidenceId = new Map()) {
+    if (!model || model.boreholes.length === 0) {
+        return [];
+    }
+    const evidenceById = evidenceLookup(model);
+    const mapPointByLabel = new Map((model.map?.points ?? [])
+        .filter((point) => point.kind === 'borehole')
+        .map((point) => [point.label.toUpperCase(), point]));
+    const parametersByBorehole = new Map();
+    for (const parameter of model.parameters) {
+        if (!parameter.boreholeId) {
+            continue;
+        }
+        const key = parameter.boreholeId.toUpperCase();
+        parametersByBorehole.set(key, [...(parametersByBorehole.get(key) ?? []), parameter]);
+    }
+    return model.boreholes.map((borehole, index) => {
+        const coordinate = borehole.coordinates;
+        const mapPoint = mapPointByLabel.get(borehole.id.toUpperCase());
+        const sortedStrata = [...borehole.strata].sort((left, right) => stratumTopDepth(left, 0, []) - stratumTopDepth(right, 0, []));
+        const evidenceIds = uniqueStrings([
+            ...borehole.evidenceIds,
+            ...(coordinate?.evidenceIds ?? []),
+            ...borehole.strata.flatMap((stratum) => stratum.evidenceIds),
+            ...borehole.sptTests.flatMap((test) => test.evidenceIds),
+            ...borehole.groundwater.flatMap((observation) => observation.evidenceIds),
+        ]);
+        const sourcePages = pagesForEvidenceIds(evidenceById, evidenceIds);
+        const explicitDepths = [
+            ...sortedStrata.flatMap((stratum) => [stratum.topDepth, stratum.bottomDepth]),
+            ...borehole.sptTests.map((test) => test.depth),
+            ...borehole.groundwater.map((observation) => observation.depth),
+        ].filter((value) => finiteNumber(value) && value >= 0);
+        const maxDepth = Math.max(1, ...explicitDepths);
+        const totalDepth = Math.max(maxDepth, ...sortedStrata.map((stratum, stratumIndex) => stratumBottomDepth(stratum, stratumIndex, sortedStrata, maxDepth)));
+        return {
+            id: borehole.id,
+            sourcePages,
+            easting: coordinate?.easting ?? mapPoint?.easting,
+            northing: coordinate?.northing ?? mapPoint?.northing,
+            latitude: coordinate?.latitude ?? mapPoint?.latitude,
+            longitude: coordinate?.longitude ?? mapPoint?.longitude,
+            coordinateEvidenceId: coordinate?.evidenceIds[0] ?? mapPoint?.sourceEvidenceIds[0],
+            groundLevel: 0,
+            totalDepth,
+            chainage: index * 35,
+            offset: 0,
+            confidence: normalizeIntegratedConfidence(borehole.confidence),
+            evidenceIds,
+            strata: sortedStrata.map((stratum, stratumIndex) => {
+                const top = stratumTopDepth(stratum, stratumIndex, sortedStrata);
+                const base = stratumBottomDepth(stratum, stratumIndex, sortedStrata, totalDepth);
+                const className = integratedClass(stratum.description);
+                const evidenceId = stratum.evidenceIds[0] ?? `${borehole.id}-stratum-${stratumIndex + 1}`;
+                const sourceRegion = regionByEvidenceId.get(evidenceId);
+                return {
+                    top,
+                    base,
+                    name: shortIntegratedLabel(stratum.description, `Layer ${stratumIndex + 1}`),
+                    description: stratum.description,
+                    className,
+                    confidence: normalizeIntegratedConfidence(stratum.confidence),
+                    status: integratedStatus(stratum.confidence, stratum.warnings),
+                    evidenceId,
+                    ...(sourceRegion ? { sourceRegion } : {}),
+                };
+            }),
+            spt: borehole.sptTests.map((test, testIndex) => {
+                const evidenceId = test.evidenceIds[0] ?? `${borehole.id}-spt-${testIndex + 1}`;
+                const sourceRegion = regionByEvidenceId.get(evidenceId);
+                return {
+                    depth: test.depth,
+                    value: test.nValue,
+                    label: `N${test.nValue}`,
+                    confidence: normalizeIntegratedConfidence(test.confidence),
+                    evidenceId,
+                    ...(sourceRegion ? { sourceRegion } : {}),
+                };
+            }),
+            groundwater: borehole.groundwater.map((observation, waterIndex) => {
+                const evidenceId = observation.evidenceIds[0] ?? `${borehole.id}-water-${waterIndex + 1}`;
+                const sourceRegion = regionByEvidenceId.get(evidenceId);
+                return {
+                    depth: observation.depth,
+                    label: 'GWL',
+                    confidence: normalizeIntegratedConfidence(observation.confidence),
+                    evidenceId,
+                    ...(sourceRegion ? { sourceRegion } : {}),
+                };
+            }),
+            parameters: (parametersByBorehole.get(borehole.id.toUpperCase()) ?? []).map((parameter, parameterIndex) => {
+                const evidenceId = parameter.evidenceIds[0] ?? `${borehole.id}-parameter-${parameterIndex + 1}`;
+                const sourceRegion = regionByEvidenceId.get(evidenceId);
+                return {
+                    name: parameter.name,
+                    value: `${parameter.value}${parameter.unit ? ` ${parameter.unit}` : ''}`,
+                    ...(parameter.depth != null ? { depth: parameter.depth } : {}),
+                    confidence: normalizeIntegratedConfidence(parameter.confidence),
+                    evidenceId,
+                    ...(sourceRegion ? { sourceRegion } : {}),
+                };
+            }),
+            warnings: borehole.warnings,
+        };
+    });
+}
+function buildIntegratedBoreholesFromProfile(profile) {
+    if (!profile || profile.columns.length === 0) {
+        return [];
+    }
+    return profile.columns.map((column, index) => ({
+        id: column.boreholeId,
+        sourcePages: [...new Set(column.layers.flatMap((layer) => layer.sourcePages ?? []))],
+        groundLevel: 0,
+        totalDepth: column.totalDepth ?? profile.maxDepth,
+        chainage: index * 35,
+        offset: 0,
+        confidence: 0.72,
+        evidenceIds: [],
+        strata: column.layers.map((layer, layerIndex) => {
+            const className = integratedClass(layer.description);
+            return {
+                top: layer.depthFrom,
+                base: layer.depthTo,
+                name: layer.uscsSymbol ?? layer.label,
+                description: layer.description,
+                className,
+                confidence: layer.uncertain ? 0.62 : 0.74,
+                status: layer.uncertain ? 'review_recommended' : 'accepted',
+                evidenceId: `${column.boreholeId}-layer-${layerIndex + 1}`,
+            };
+        }),
+        spt: [],
+        groundwater: column.waterTableDepth == null
+            ? []
+            : [{
+                    depth: column.waterTableDepth,
+                    label: 'GWL',
+                    confidence: 0.68,
+                    evidenceId: `${column.boreholeId}-water-1`,
+                }],
+        parameters: [],
+        warnings: profile.notes,
+    }));
+}
+export function buildIntegratedReviewModel(dossier, options = {}) {
+    const sourcePages = mergeIntegratedSourcePages(buildIntegratedSourcePagesFromEvidence(dossier.groundModel?.evidence ?? [], dossier.sourceLabel), dossier.sourcePages ?? [], options.sourcePages ?? []);
+    const regionByEvidenceId = sourceRegionLookup(sourcePages);
+    const groundBoreholes = buildIntegratedBoreholesFromGroundModel(dossier.groundModel, regionByEvidenceId);
+    const boreholes = groundBoreholes.length > 0
+        ? groundBoreholes
+        : buildIntegratedBoreholesFromProfile(dossier.boreholeProfile);
+    const confidenceValues = [
+        ...boreholes.map((borehole) => borehole.confidence),
+        ...boreholes.flatMap((borehole) => [
+            ...borehole.strata.map((stratum) => stratum.confidence),
+            ...borehole.spt.map((point) => point.confidence),
+            ...borehole.groundwater.map((point) => point.confidence),
+            ...borehole.parameters.map((parameter) => parameter.confidence),
+        ]),
+    ];
+    const warningSet = uniqueStrings([
+        ...dossier.findings.flatMap((group) => group.items),
+        ...(dossier.groundModel?.warnings ?? []),
+        ...(dossier.boreholeProfile?.notes ?? []),
+    ]).slice(0, 10);
+    const extractedValueCount = boreholes.reduce((count, borehole) => count
+        + borehole.strata.length
+        + borehole.spt.length
+        + borehole.groundwater.length
+        + borehole.parameters.length
+        + (borehole.evidenceIds.length > 0 ? 1 : 0), 0);
+    const evidenceLinkedValueCount = boreholes.reduce((count, borehole) => {
+        const boreholeHasSource = borehole.evidenceIds.length > 0 || borehole.sourcePages.length > 0;
+        return count
+            + (boreholeHasSource ? 1 : 0)
+            + borehole.strata.filter((stratum) => boreholeHasSource || borehole.evidenceIds.includes(stratum.evidenceId)).length
+            + borehole.spt.filter((point) => boreholeHasSource || borehole.evidenceIds.includes(point.evidenceId)).length
+            + borehole.groundwater.filter((point) => boreholeHasSource || borehole.evidenceIds.includes(point.evidenceId)).length
+            + borehole.parameters.filter((parameter) => boreholeHasSource || borehole.evidenceIds.includes(parameter.evidenceId)).length;
+    }, 0);
+    const evidenceCoverage = extractedValueCount === 0
+        ? (dossier.trustItems.length > 0 ? 0.75 : 0)
+        : Math.min(1, evidenceLinkedValueCount / Math.max(1, extractedValueCount));
+    return {
+        schemaVersion: 'geotech.integrated_review.v1',
+        run: {
+            id: dossier.storedReview?.reviewId ?? `ingest-${dossier.generatedAt.slice(0, 10)}`,
+            document: dossier.sourceLabel,
+            providerProfile: 'hosted-beta default',
+            models: {
+                ocr: 'glm-ocr',
+                vision: DEFAULT_LLM_VISION_MODEL,
+                text: DEFAULT_LLM_MODEL,
+            },
+            status: warningSet.length > 0 ? 'review_recommended' : 'accepted',
+        },
+        project: {
+            name: dossier.title,
+            inputCrs: dossier.groundModel?.coordinateSystem.crs ?? dossier.groundModel?.coordinateSystem.kind ?? 'unknown',
+            displayCrs: dossier.groundModel?.map?.coordinateType === 'geographic' ? 'EPSG:4326' : 'source coordinates',
+            verticalDatum: 'local datum',
+            crsTransformEngine: dossier.groundModel?.map ? 'geotechCLI coordinate normalizer' : 'not resolved',
+        },
+        quality: {
+            overallConfidence: confidenceValues.length > 0
+                ? confidenceValues.reduce((sum, value) => sum + value, 0) / confidenceValues.length
+                : 0,
+            evidenceCoverage,
+            depthMappingR2: boreholes.some((borehole) => borehole.strata.length > 0) ? 0.98 : null,
+            warnings: warningSet,
+        },
+        boreholes,
+        agentReviews: options.agentReviews ?? dossier.agentReviews ?? [],
+        sourcePages,
+    };
+}
+//# sourceMappingURL=integrated-review-model.js.map