@tiangong-lca/cli 0.0.7 → 0.0.8

package/dist/src/lib/process-required-fields.js

@@ -0,0 +1,810 @@
+import path from 'node:path';
+import { writeJsonArtifact, writeJsonLinesArtifact } from './artifacts.js';
+import { CliError } from './errors.js';
+import { cloneJson, datasetRoot, firstNonEmpty, isRecord, materializeDatasetRows, } from './dataset-local.js';
+const ANNUAL_SUPPLY_FIELD = 'processDataSet.modellingAndValidation.dataSourcesTreatmentAndRepresentativeness.annualSupplyOrProductionVolume';
+const ANNUAL_SUPPLY_ROOT_FIELD = 'modellingAndValidation.dataSourcesTreatmentAndRepresentativeness.annualSupplyOrProductionVolume';
+const NUMERIC_TEXT_WITH_SUFFIX_PATTERN = /^[+-]?(\d+(\.\d*)?|\.\d+)([Ee][+-]?\d+)?\s+\S.*$/u;
+const ANNUAL_PERIOD_PATTERN = /(?:\/\s*(?:year|yr|a)\b|\bper\s+(?:year|annum)\b|\/\s*年|每年|年度|年供应|年产)/iu;
+const CJK_TEXT_PATTERN = /[\p{Script=Han}]/u;
+const NET_CALORIFIC_VALUE_ID = '93a60a56-a3c8-11da-a746-0800200c9a66';
+const DEFAULT_COMPLIANCE_SYSTEM = {
+    '@refObjectId': 'c84c4185-d1b0-44fc-823e-d2ec630c7906',
+    '@type': 'source data set',
+    '@uri': 'https://tiangong.earth/datasets/c84c4185-d1b0-44fc-823e-d2ec630c7906',
+    '@version': '00.00.001',
+    'common:shortDescription': {
+        '@xml:lang': 'en',
+        '#text': 'Environmental Footprint (EF) 3.1',
+    },
+};
+const DEFAULT_COMPLIANCE_DECLARATION = {
+    'common:referenceToComplianceSystem': DEFAULT_COMPLIANCE_SYSTEM,
+    'common:approvalOfOverallCompliance': 'Not defined',
+    'common:nomenclatureCompliance': 'Not defined',
+    'common:methodologicalCompliance': 'Not defined',
+    'common:reviewCompliance': 'Not defined',
+    'common:documentationCompliance': 'Not defined',
+    'common:qualityCompliance': 'Not defined',
+};
+const REQUIRED_COMPLIANCE_FIELDS = [
+    'common:approvalOfOverallCompliance',
+    'common:nomenclatureCompliance',
+    'common:methodologicalCompliance',
+    'common:reviewCompliance',
+    'common:documentationCompliance',
+    'common:qualityCompliance',
+];
+function normalizeUnit(value) {
+    const token = value?.trim();
+    return token || 'unit';
+}
+function sourceLanguageForText(value, fallback = 'en') {
+    return CJK_TEXT_PATTERN.test(value) ? 'zh' : fallback;
+}
+function textValue(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return String(value);
+    }
+    return null;
+}
+function asList(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return value === undefined || value === null ? [] : [value];
+}
+function valueAtPath(root, pathExpression) {
+    let current = root;
+    for (const segment of pathExpression.split('.')) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function annualSupplyItems(value) {
+    return asList(value).filter((item) => {
+        return (isRecord(item) && typeof item['#text'] === 'string' && typeof item['@xml:lang'] === 'string');
+    });
+}
+function isValidAnnualSupplyVolume(value) {
+    const items = annualSupplyItems(value);
+    return (items.length > 0 &&
+        items.every((item) => {
+            const text = item['#text'].trim();
+            return NUMERIC_TEXT_WITH_SUFFIX_PATTERN.test(text) && ANNUAL_PERIOD_PATTERN.test(text);
+        }));
+}
+function isValidReview(value) {
+    return asList(value).some((item) => isRecord(item) && Boolean(firstNonEmpty(item['@type'])));
+}
+function isValidComplianceDeclaration(value) {
+    return asList(value).some((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        const complianceSystem = isRecord(item['common:referenceToComplianceSystem'])
+            ? item['common:referenceToComplianceSystem']
+            : {};
+        return (Boolean(firstNonEmpty(complianceSystem['@refObjectId'])) &&
+            REQUIRED_COMPLIANCE_FIELDS.every((field) => Boolean(firstNonEmpty(item[field]))));
+    });
+}
+export function collectProcessRequiredFieldIssues(payload) {
+    const root = datasetRoot(payload, 'process');
+    const modelling = isRecord(root.modellingAndValidation) ? root.modellingAndValidation : {};
+    const dataSources = isRecord(modelling.dataSourcesTreatmentAndRepresentativeness)
+        ? modelling.dataSourcesTreatmentAndRepresentativeness
+        : null;
+    if (!dataSources) {
+        return [
+            {
+                code: 'process_data_sources_treatment_missing',
+                message: 'Process payload must include dataSourcesTreatmentAndRepresentativeness.',
+                path: 'processDataSet.modellingAndValidation.dataSourcesTreatmentAndRepresentativeness',
+            },
+        ];
+    }
+    const issues = [];
+    const validation = isRecord(modelling.validation) ? modelling.validation : {};
+    if (!isValidReview(validation.review)) {
+        issues.push({
+            code: 'process_validation_review_missing',
+            message: 'Process payload must include modellingAndValidation.validation.review.',
+            path: 'processDataSet.modellingAndValidation.validation.review',
+        });
+    }
+    const complianceDeclarations = isRecord(modelling.complianceDeclarations)
+        ? modelling.complianceDeclarations
+        : {};
+    if (!isValidComplianceDeclaration(complianceDeclarations.compliance)) {
+        issues.push({
+            code: 'process_compliance_declaration_missing',
+            message: 'Process payload must include modellingAndValidation.complianceDeclarations.compliance.',
+            path: 'processDataSet.modellingAndValidation.complianceDeclarations.compliance',
+        });
+    }
+    const annualSupply = dataSources.annualSupplyOrProductionVolume;
+    if (isValidAnnualSupplyVolume(annualSupply)) {
+        return issues;
+    }
+    const items = annualSupplyItems(annualSupply);
+    if (items.length === 0) {
+        return [
+            ...issues,
+            {
+                code: 'annual_supply_or_production_volume_missing',
+                message: 'Process payload must include annualSupplyOrProductionVolume as numeric text with a unit or context suffix.',
+                path: ANNUAL_SUPPLY_FIELD,
+            },
+        ];
+    }
+    if (items.every((item) => NUMERIC_TEXT_WITH_SUFFIX_PATTERN.test(item['#text'].trim())) &&
+        items.some((item) => !ANNUAL_PERIOD_PATTERN.test(item['#text'].trim()))) {
+        return [
+            ...issues,
+            {
+                code: 'annual_supply_or_production_volume_not_annualized',
+                message: 'annualSupplyOrProductionVolume must express an annualized amount such as "3.6 MJ/year" or "3.6 MJ/年", not a reference-flow description.',
+                path: ANNUAL_SUPPLY_FIELD,
+            },
+        ];
+    }
+    return [
+        ...issues,
+        {
+            code: 'annual_supply_or_production_volume_invalid',
+            message: 'annualSupplyOrProductionVolume must start with a real number followed by a unit or context suffix.',
+            path: ANNUAL_SUPPLY_FIELD,
+        },
+    ];
+}
+function issuePath(pathSegments) {
+    return pathSegments.length > 0 ? pathSegments.map(String).join('.') : '<root>';
+}
+function collectPlaceholderIssuesFromValue(value, pathSegments, issues) {
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if ((pathSegments.at(-1) === 'common:referenceYear' && normalized === '9999') ||
+            normalized.includes('tidas_import_placeholder') ||
+            normalized.includes('tidas_import_trace_v1') ||
+            normalized.includes('not declared in source package') ||
+            normalized.includes('source package metadata not declared') ||
+            normalized === '<null>' ||
+            /(^|[\s"'`])(?:\/users\/|\/home\/|[a-z]:\\)/iu.test(value) ||
+            normalized.includes('placeholder.example') ||
+            normalized.includes('pending confirmation') ||
+            /00000000-0000-0000-0000-0000000000[0-9a-f]{2}/u.test(normalized)) {
+            issues.push({
+                code: 'process_placeholder_content',
+                message: 'Process payload contains placeholder or pending-confirmation content that must be replaced before save or publish.',
+                path: issuePath(pathSegments),
+            });
+        }
+        return;
+    }
+    if (typeof value === 'number') {
+        if (pathSegments.at(-1) === 'common:referenceYear' && value === 9999) {
+            issues.push({
+                code: 'process_placeholder_content',
+                message: 'Process payload contains placeholder or pending-confirmation content that must be replaced before save or publish.',
+                path: issuePath(pathSegments),
+            });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectPlaceholderIssuesFromValue(item, [...pathSegments, index], issues));
+        return;
+    }
+    if (isRecord(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            collectPlaceholderIssuesFromValue(child, [...pathSegments, key], issues);
+        }
+    }
+}
+export function collectProcessPlaceholderIssues(payload) {
+    const root = datasetRoot(payload, 'process');
+    const issues = [];
+    collectPlaceholderIssuesFromValue(root, ['processDataSet'], issues);
+    return issues;
+}
+function hasPlaceholderContent(value) {
+    const issues = [];
+    collectPlaceholderIssuesFromValue(value, [], issues);
+    return issues.length > 0;
+}
+function removePlaceholderField(parent, key, fieldPath, completions) {
+    if (!hasPlaceholderContent(parent[key])) {
+        return;
+    }
+    delete parent[key];
+    completions.push({
+        field_path: fieldPath,
+        source: 'placeholder_repair',
+        value: [],
+        amount: null,
+        unit: null,
+        reference_exchange_internal_id: null,
+        basis: 'Removed placeholder review metadata because the dataset is marked Not reviewed and no completed review evidence is present.',
+    });
+}
+function repairPlaceholderReviewMetadata(root) {
+    const modelling = isRecord(root.modellingAndValidation) ? root.modellingAndValidation : {};
+    const validation = isRecord(modelling.validation) ? modelling.validation : null;
+    if (!validation) {
+        return [];
+    }
+    const completions = [];
+    const validationPath = 'processDataSet.modellingAndValidation.validation';
+    for (const key of [
+        'reviewDetails',
+        'common:reviewDetails',
+        'common:referenceToCompleteReviewReport',
+        'common:referenceToNameOfReviewerAndInstitution',
+    ]) {
+        removePlaceholderField(validation, key, `${validationPath}.${key}`, completions);
+    }
+    if (isRecord(validation.review)) {
+        const reviewPath = `${validationPath}.review`;
+        for (const key of [
+            'reviewDetails',
+            'common:reviewDetails',
+            'common:referenceToCompleteReviewReport',
+            'common:referenceToNameOfReviewerAndInstitution',
+        ]) {
+            removePlaceholderField(validation.review, key, `${reviewPath}.${key}`, completions);
+        }
+    }
+    return completions;
+}
+function addRequiredStructureCompletion(completions, fieldPath, basis) {
+    completions.push({
+        field_path: fieldPath,
+        source: 'required_structure_repair',
+        value: [],
+        amount: null,
+        unit: null,
+        reference_exchange_internal_id: null,
+        basis,
+    });
+}
+function repairRequiredProcessStructures(root) {
+    const completions = [];
+    if (!isRecord(root.modellingAndValidation)) {
+        root.modellingAndValidation = {};
+    }
+    const modelling = root.modellingAndValidation;
+    if (!isRecord(modelling.validation)) {
+        modelling.validation = {};
+    }
+    const validation = modelling.validation;
+    if (!isValidReview(validation.review)) {
+        validation.review = {
+            '@type': 'Not reviewed',
+        };
+        addRequiredStructureCompletion(completions, 'processDataSet.modellingAndValidation.validation.review', 'Inserted a conservative Not reviewed marker because UI roundtrip or source data omitted the required validation.review structure.');
+    }
+    if (!isRecord(modelling.complianceDeclarations)) {
+        modelling.complianceDeclarations = {};
+    }
+    const complianceDeclarations = modelling.complianceDeclarations;
+    if (!isValidComplianceDeclaration(complianceDeclarations.compliance)) {
+        complianceDeclarations.compliance = cloneJson(DEFAULT_COMPLIANCE_DECLARATION);
+        addRequiredStructureCompletion(completions, 'processDataSet.modellingAndValidation.complianceDeclarations.compliance', 'Inserted a conservative Not defined compliance declaration against EF 3.1 because UI roundtrip or source data omitted the required compliance structure.');
+    }
+    return completions;
+}
+function processRootForMutation(payload) {
+    if (isRecord(payload.processDataSet)) {
+        return payload.processDataSet;
+    }
+    return payload;
+}
+function selectReferenceExchange(root) {
+    const exchangesRoot = isRecord(root.exchanges) ? root.exchanges : {};
+    const exchanges = asList(exchangesRoot.exchange).filter(isRecord);
+    const processInfo = isRecord(root.processInformation) ? root.processInformation : {};
+    const quantitativeReference = isRecord(processInfo.quantitativeReference)
+        ? processInfo.quantitativeReference
+        : {};
+    const referenceId = firstNonEmpty(quantitativeReference.referenceToReferenceFlow);
+    const byReferenceId = referenceId
+        ? exchanges.find((exchange) => firstNonEmpty(exchange['@dataSetInternalID']) === referenceId)
+        : null;
+    if (byReferenceId) {
+        return byReferenceId;
+    }
+    return (exchanges.find((exchange) => exchange.quantitativeReference === true) ??
+        exchanges.find((exchange) => String(exchange.exchangeDirection ?? '').toLowerCase() === 'output') ??
+        null);
+}
+function localizedTextIncludes(value, pattern) {
+    return annualSupplyItems(value).some((item) => pattern.test(item['#text']));
+}
+function inferSpecificUnitFromFlowPayload(payload) {
+    const root = datasetRoot(payload, 'flow');
+    const flowPropertiesRoot = isRecord(root.flowProperties) ? root.flowProperties : {};
+    const flowProperties = asList(flowPropertiesRoot.flowProperty).filter(isRecord);
+    for (const flowProperty of flowProperties) {
+        const direct = firstNonEmpty(flowProperty.unit, flowProperty.referenceUnit, flowProperty.flowUnit);
+        if (direct) {
+            return direct;
+        }
+        const flowPropertyRef = isRecord(flowProperty.referenceToFlowPropertyDataSet)
+            ? flowProperty.referenceToFlowPropertyDataSet
+            : {};
+        const flowPropertyId = firstNonEmpty(flowPropertyRef['@refObjectId']);
+        const flowPropertyText = flowPropertyRef['common:shortDescription'];
+        if (flowPropertyId === NET_CALORIFIC_VALUE_ID ||
+            localizedTextIncludes(flowPropertyText, /Net calorific|净热值/u)) {
+            return 'MJ';
+        }
+    }
+    const flowInformation = isRecord(root.flowInformation) ? root.flowInformation : {};
+    const dataSetInformation = isRecord(flowInformation.dataSetInformation)
+        ? flowInformation.dataSetInformation
+        : {};
+    const classificationInformation = isRecord(dataSetInformation.classificationInformation)
+        ? dataSetInformation.classificationInformation
+        : {};
+    const classification = isRecord(classificationInformation['common:classification'])
+        ? classificationInformation['common:classification']
+        : {};
+    const classificationClasses = classification['common:class'];
+    if (localizedTextIncludes(classificationClasses, /Electrical energy|electricity|交流电|电力|电能/iu)) {
+        return 'MJ';
+    }
+    return null;
+}
+function buildFlowUnitIndex(flowRows, fallbackUnit) {
+    const index = new Map();
+    for (const row of flowRows) {
+        if (row.kind !== 'flow' || !row.id) {
+            continue;
+        }
+        const inferred = inferSpecificUnitFromFlowPayload(row.payload);
+        if (inferred && inferred !== fallbackUnit) {
+            index.set(row.id, inferred);
+        }
+    }
+    return index;
+}
+function inferUnitFromReferenceExchange(exchange, fallbackOrContext) {
+    const context = typeof fallbackOrContext === 'string' ? { defaultUnit: fallbackOrContext } : fallbackOrContext;
+    const fallbackUnit = context.defaultUnit;
+    const flowRef = isRecord(exchange.referenceToFlowDataSet) ? exchange.referenceToFlowDataSet : {};
+    const refObjectId = firstNonEmpty(flowRef['@refObjectId']);
+    if (refObjectId) {
+        const indexedUnit = context.flowUnitById?.get(refObjectId);
+        if (indexedUnit) {
+            return indexedUnit;
+        }
+    }
+    const direct = firstNonEmpty(exchange.unit, exchange.referenceUnit, exchange.flowUnit);
+    if (direct) {
+        return direct;
+    }
+    const shortDescriptions = flowRef['common:shortDescription'];
+    if (localizedTextIncludes(shortDescriptions, /MJ|net calorific|lower calorific|Electrical energy|electricity|净热值|低位发热|交流电|电力|电能/iu)) {
+        return 'MJ';
+    }
+    const flowProperty = isRecord(exchange.flowProperty) ? exchange.flowProperty : {};
+    const flowPropertyRef = isRecord(flowProperty.referenceToFlowPropertyDataSet)
+        ? flowProperty.referenceToFlowPropertyDataSet
+        : {};
+    const flowPropertyId = firstNonEmpty(flowPropertyRef['@refObjectId']);
+    const flowPropertyText = flowPropertyRef['common:shortDescription'];
+    if (refObjectId === NET_CALORIFIC_VALUE_ID ||
+        flowPropertyId === NET_CALORIFIC_VALUE_ID ||
+        localizedTextIncludes(flowPropertyText, /Net calorific|净热值/u)) {
+        return 'MJ';
+    }
+    return fallbackUnit;
+}
+function buildAnnualSupplyValue(amount, unit) {
+    return [{ '@xml:lang': 'en', '#text': `${amount} ${unit}/year` }];
+}
+function annualSupplyTextParts(value) {
+    const match = /^\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][+-]?\d+)?)\s+(\S.*)$/u.exec(value);
+    return match ? { amount: match[1], unit: match[2].trim() } : null;
+}
+function annualSupplyValueFromText(value) {
+    const text = value.trim();
+    if (!NUMERIC_TEXT_WITH_SUFFIX_PATTERN.test(text) || !ANNUAL_PERIOD_PATTERN.test(text)) {
+        return null;
+    }
+    const parts = annualSupplyTextParts(text);
+    return {
+        value: [{ '@xml:lang': sourceLanguageForText(text), '#text': text }],
+        amount: parts.amount,
+        unit: parts.unit,
+        basis: 'Evidence provided a complete annual supply / production volume text value.',
+    };
+}
+function normalizeAnnualSupplyEvidenceValue(candidate, context) {
+    if (typeof candidate === 'string') {
+        return annualSupplyValueFromText(candidate);
+    }
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        const amount = String(candidate);
+        return {
+            value: buildAnnualSupplyValue(amount, context.defaultUnit),
+            amount,
+            unit: context.defaultUnit,
+            basis: 'Evidence provided a numeric annual supply / production volume; the configured default unit was applied.',
+        };
+    }
+    if (isValidAnnualSupplyVolume(candidate)) {
+        const value = [
+            annualSupplyItems(candidate).map((item) => ({
+                '@xml:lang': item['@xml:lang'],
+                '#text': item['#text'].trim(),
+            }))[0],
+        ];
+        const parts = annualSupplyTextParts(value[0]['#text']);
+        return {
+            value,
+            amount: parts.amount,
+            unit: parts.unit,
+            basis: 'Evidence provided a validated source-language annual supply / production volume value.',
+        };
+    }
+    if (!isRecord(candidate)) {
+        return null;
+    }
+    for (const key of [
+        'value',
+        'text',
+        'value_text',
+        'valueText',
+        'annualSupplyOrProductionVolume',
+        'annual_supply_or_production_volume',
+    ]) {
+        const nested = normalizeAnnualSupplyEvidenceValue(candidate[key], context);
+        if (nested) {
+            return nested;
+        }
+    }
+    const preferredLanguage = textValue(candidate.source_language ??
+        candidate.sourceLanguage ??
+        candidate.lang ??
+        candidate['@xml:lang'])?.toLowerCase();
+    const english = textValue(candidate.en ?? candidate.english);
+    const chinese = textValue(candidate.zh ?? candidate.chinese ?? candidate['zh-CN']);
+    const localized = [
+        english ? { '@xml:lang': 'en', '#text': english } : null,
+        chinese ? { '@xml:lang': 'zh', '#text': chinese } : null,
+    ].filter((item) => Boolean(item));
+    if (localized.length > 0 && isValidAnnualSupplyVolume(localized)) {
+        const selected = localized.find((item) => item['@xml:lang'].toLowerCase() === preferredLanguage) ??
+            localized[0];
+        const value = [selected];
+        const parts = annualSupplyTextParts(selected['#text']);
+        return {
+            value,
+            amount: parts.amount,
+            unit: parts.unit,
+            basis: 'Evidence provided a language-specific annual supply / production volume text value.',
+        };
+    }
+    const amount = textValue(candidate.amount ?? candidate.value_amount ?? candidate.valueAmount);
+    const unit = normalizeUnit(textValue(candidate.unit ?? candidate.uom ?? candidate.reference_unit ?? candidate.referenceUnit) ?? context.defaultUnit);
+    if (amount) {
+        return {
+            value: buildAnnualSupplyValue(amount, unit),
+            amount,
+            unit,
+            basis: 'Evidence provided annual supply / production volume amount and unit as structured fields.',
+        };
+    }
+    return null;
+}
+function isAnnualSupplyEvidencePath(pathExpression) {
+    if (!pathExpression) {
+        return false;
+    }
+    return (pathExpression === ANNUAL_SUPPLY_FIELD ||
+        pathExpression === ANNUAL_SUPPLY_ROOT_FIELD ||
+        pathExpression.endsWith(`.${ANNUAL_SUPPLY_ROOT_FIELD}`) ||
+        pathExpression.endsWith('.annualSupplyOrProductionVolume'));
+}
+function fieldPathFromEvidenceEntry(entry) {
+    return firstNonEmpty(entry.field_path, entry.fieldPath, entry.path, entry.field, entry.target_path, entry.targetPath);
+}
+function findAnnualSupplyEvidenceEntry(container, context) {
+    if (!isRecord(container)) {
+        return null;
+    }
+    const directPath = fieldPathFromEvidenceEntry(container);
+    if (isAnnualSupplyEvidencePath(directPath)) {
+        const directValue = normalizeAnnualSupplyEvidenceValue(container, context);
+        if (directValue) {
+            return directValue;
+        }
+    }
+    for (const key of [
+        'field_values',
+        'fieldValues',
+        'field_bindings',
+        'fieldBindings',
+        'bindings',
+    ]) {
+        const entries = asList(container[key]).filter(isRecord);
+        for (const entry of entries) {
+            if (!isAnnualSupplyEvidencePath(fieldPathFromEvidenceEntry(entry))) {
+                continue;
+            }
+            const value = normalizeAnnualSupplyEvidenceValue(entry, context);
+            if (value) {
+                return value;
+            }
+        }
+    }
+    return null;
+}
+function findAnnualSupplyEvidenceValue(row, payload, context) {
+    const explicitPaths = [
+        'annualSupplyOrProductionVolume',
+        'annual_supply_or_production_volume',
+        'required_fields.annualSupplyOrProductionVolume',
+        'requiredFields.annualSupplyOrProductionVolume',
+        'authoring.required_fields.annualSupplyOrProductionVolume',
+        'authoring.requiredFields.annualSupplyOrProductionVolume',
+        'process_authoring.required_fields.annualSupplyOrProductionVolume',
+        'processAuthoring.requiredFields.annualSupplyOrProductionVolume',
+    ];
+    for (const source of [row, payload]) {
+        for (const explicitPath of explicitPaths) {
+            const value = normalizeAnnualSupplyEvidenceValue(valueAtPath(source, explicitPath), context);
+            if (value) {
+                return value;
+            }
+        }
+    }
+    const evidencePaths = [
+        'evidence_manifest',
+        'evidenceManifest',
+        'authoring_evidence',
+        'authoringEvidence',
+        'process_authoring.evidence_manifest',
+        'processAuthoring.evidenceManifest',
+    ];
+    for (const source of [row, payload]) {
+        for (const evidencePath of evidencePaths) {
+            const value = findAnnualSupplyEvidenceEntry(valueAtPath(source, evidencePath), context);
+            if (value) {
+                return value;
+            }
+        }
+    }
+    return null;
+}
+function ensureDataSources(root) {
+    if (!isRecord(root.modellingAndValidation)) {
+        root.modellingAndValidation = {};
+    }
+    const modelling = root.modellingAndValidation;
+    if (!isRecord(modelling.dataSourcesTreatmentAndRepresentativeness)) {
+        modelling.dataSourcesTreatmentAndRepresentativeness = {};
+    }
+    return modelling.dataSourcesTreatmentAndRepresentativeness;
+}
+function cloneRowWithPayload(row) {
+    const clonedRow = cloneJson(row.row);
+    if (isRecord(clonedRow.json_ordered)) {
+        return { row: clonedRow, payload: clonedRow.json_ordered };
+    }
+    if (isRecord(clonedRow.jsonOrdered)) {
+        return { row: clonedRow, payload: clonedRow.jsonOrdered };
+    }
+    if (isRecord(clonedRow.json)) {
+        return { row: clonedRow, payload: clonedRow.json };
+    }
+    if (isRecord(clonedRow.payload)) {
+        return { row: clonedRow, payload: clonedRow.payload };
+    }
+    if (isRecord(clonedRow.process)) {
+        return { row: clonedRow, payload: clonedRow.process };
+    }
+    return { row: clonedRow, payload: clonedRow };
+}
+function completeProcessRow(row, context) {
+    const { row: clonedRow, payload } = cloneRowWithPayload(row);
+    if (row.kind !== 'process') {
+        return {
+            row: clonedRow,
+            report: {
+                index: row.index,
+                id: row.id,
+                version: row.version,
+                type: row.kind,
+                status: 'skipped',
+                issues: [],
+                completions: [],
+            },
+        };
+    }
+    const root = processRootForMutation(payload);
+    const placeholderCompletions = repairPlaceholderReviewMetadata(root);
+    const requiredStructureCompletions = repairRequiredProcessStructures(root);
+    const repairCompletions = [...placeholderCompletions, ...requiredStructureCompletions];
+    const existingIssues = collectProcessRequiredFieldIssues(payload);
+    const placeholderIssues = collectProcessPlaceholderIssues(payload);
+    if (existingIssues.length === 0 && placeholderIssues.length === 0) {
+        return {
+            row: clonedRow,
+            report: {
+                index: row.index,
+                id: row.id,
+                version: row.version,
+                type: row.kind,
+                status: repairCompletions.length > 0 ? 'completed' : 'existing',
+                issues: [],
+                completions: repairCompletions,
+            },
+        };
+    }
+    if (placeholderIssues.length > 0) {
+        return {
+            row: clonedRow,
+            report: {
+                index: row.index,
+                id: row.id,
+                version: row.version,
+                type: row.kind,
+                status: 'blocked',
+                issues: [...existingIssues, ...placeholderIssues],
+                completions: repairCompletions,
+            },
+        };
+    }
+    const evidenceValue = findAnnualSupplyEvidenceValue(clonedRow, payload, context);
+    if (evidenceValue) {
+        const dataSources = ensureDataSources(root);
+        dataSources.annualSupplyOrProductionVolume = evidenceValue.value;
+        const completion = {
+            field_path: ANNUAL_SUPPLY_FIELD,
+            source: 'evidence',
+            value: evidenceValue.value,
+            amount: evidenceValue.amount,
+            unit: evidenceValue.unit,
+            reference_exchange_internal_id: null,
+            basis: evidenceValue.basis,
+        };
+        return {
+            row: clonedRow,
+            report: {
+                index: row.index,
+                id: row.id,
+                version: row.version,
+                type: row.kind,
+                status: 'completed',
+                issues: [],
+                completions: [...repairCompletions, completion],
+            },
+        };
+    }
+    return {
+        row: clonedRow,
+        report: {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.kind,
+            status: 'blocked',
+            issues: [
+                ...existingIssues,
+                {
+                    code: 'annual_supply_evidence_missing',
+                    message: 'Could not complete annualSupplyOrProductionVolume because no source evidence value was provided.',
+                    path: ANNUAL_SUPPLY_FIELD,
+                },
+            ],
+            completions: repairCompletions,
+        },
+    };
+}
+function buildFiles(outPath, outDir) {
+    if (!outDir) {
+        return {
+            output_rows: path.resolve(outPath),
+            report: null,
+            evidence: null,
+        };
+    }
+    const resolved = path.resolve(outDir);
+    return {
+        output_rows: path.resolve(outPath),
+        report: path.join(resolved, 'outputs', 'process-required-fields-report.json'),
+        evidence: path.join(resolved, 'outputs', 'process-required-fields-evidence.jsonl'),
+    };
+}
+function requireOutputPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new CliError('Missing required --out value.', {
+            code: 'PROCESS_REQUIRED_FIELDS_OUT_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return trimmed;
+}
+export async function runProcessRequiredFieldsComplete(options) {
+    const outPath = requireOutputPath(options.outPath);
+    const outDir = options.outDir?.trim() ? options.outDir.trim() : null;
+    const defaultUnit = normalizeUnit(options.defaultUnit);
+    const rows = materializeDatasetRows(options.inputPath, options.rawInput);
+    const flowRows = options.flowInputPath?.trim()
+        ? materializeDatasetRows(options.flowInputPath, options.rawFlowInput)
+        : [];
+    const flowUnitById = buildFlowUnitIndex(flowRows, defaultUnit);
+    const completed = rows.map((row) => completeProcessRow(row, { defaultUnit, flowUnitById }));
+    const rowReports = completed.map((item) => item.report);
+    const files = buildFiles(outPath, outDir);
+    const blockers = rowReports.filter((row) => row.status === 'blocked');
+    const report = {
+        generated_at_utc: (options.now ?? new Date()).toISOString(),
+        input_path: path.resolve(options.inputPath),
+        out_path: path.resolve(outPath),
+        out_dir: outDir ? path.resolve(outDir) : null,
+        status: blockers.length > 0 ? 'completed_with_blockers' : 'completed',
+        default_unit: defaultUnit,
+        counts: {
+            total: rowReports.length,
+            processes: rowReports.filter((row) => row.type === 'process').length,
+            completed: rowReports.filter((row) => row.status === 'completed').length,
+            existing: rowReports.filter((row) => row.status === 'existing').length,
+            blocked: blockers.length,
+            skipped: rowReports.filter((row) => row.status === 'skipped').length,
+        },
+        files,
+        rows: rowReports,
+    };
+    writeJsonLinesArtifact(files.output_rows, completed.map((item) => item.row));
+    if (files.report) {
+        writeJsonArtifact(files.report, report);
+    }
+    if (files.evidence) {
+        writeJsonLinesArtifact(files.evidence, rowReports.flatMap((row) => row.completions.map((completion) => ({
+            row_index: row.index,
+            dataset_id: row.id,
+            dataset_version: row.version,
+            ...completion,
+        }))));
+    }
+    return report;
+}
+export const __testInternals = {
+    ANNUAL_SUPPLY_ROOT_FIELD,
+    annualSupplyTextParts,
+    annualSupplyValueFromText,
+    cloneRowWithPayload,
+    collectProcessRequiredFieldIssues,
+    completeProcessRow,
+    ensureDataSources,
+    fieldPathFromEvidenceEntry,
+    findAnnualSupplyEvidenceValue,
+    findAnnualSupplyEvidenceEntry,
+    buildFlowUnitIndex,
+    inferUnitFromReferenceExchange,
+    inferSpecificUnitFromFlowPayload,
+    issuePath,
+    isAnnualSupplyEvidencePath,
+    isValidComplianceDeclaration,
+    isValidAnnualSupplyVolume,
+    isValidReview,
+    normalizeAnnualSupplyEvidenceValue,
+    repairRequiredProcessStructures,
+    requireOutputPath,
+    selectReferenceExchange,
+    textValue,
+    valueAtPath,
+};
+//# sourceMappingURL=process-required-fields.js.map