@tiangong-lca/cli 0.0.1

package/dist/src/lib/flow-regen-product.js

@@ -0,0 +1,1396 @@
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { writeJsonArtifact, writeJsonLinesArtifact, writeTextArtifact } from './artifacts.js';
+import { CliError } from './errors.js';
+import { coerceText, deepGet, extractFlowRecord, flowDatasetFromRow, isRecord, listify, loadRowsFromFile, normalizeText, } from './flow-governance.js';
+import { resolveRepoRootFrom } from './validation.js';
+const EMERGY_TEXT_KEYWORDS = [
+    'emergy',
+    '能值',
+    '太阳能值',
+    'solar emergy',
+    'solar emjoule',
+    'sej',
+];
+function resolveCliRepoRoot() {
+    return resolveRepoRootFrom(path.dirname(fileURLToPath(import.meta.url)));
+}
+function buildSdkCandidates() {
+    return ['@tiangong-lca/tidas-sdk/core'];
+}
+function resolveSdkModuleFromCandidates(requireFn, candidates) {
+    const details = [];
+    for (const candidate of candidates) {
+        try {
+            const loaded = requireFn(candidate);
+            if (typeof loaded.createProcess === 'function') {
+                return {
+                    ...loaded,
+                    location: candidate,
+                };
+            }
+            details.push(`Candidate missing createProcess export: ${candidate}`);
+        }
+        catch (error) {
+            details.push(`Failed to load ${candidate}: ${String(error)}`);
+        }
+    }
+    throw new CliError('Unable to resolve the local tidas-sdk process factory.', {
+        code: 'FLOW_REGEN_PROCESS_SDK_NOT_FOUND',
+        exitCode: 2,
+        details,
+    });
+}
+function resolveLocalSdkModule() {
+    return resolveSdkModuleFromCandidates(createRequire(import.meta.url), buildSdkCandidates());
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function assertInputFile(inputFile, requiredCode, missingCode) {
+    if (!inputFile) {
+        throw new CliError('Missing required input file value.', {
+            code: requiredCode,
+            exitCode: 2,
+        });
+    }
+    const resolved = path.resolve(inputFile);
+    if (!existsSync(resolved)) {
+        throw new CliError(`Input file not found: ${resolved}`, {
+            code: missingCode,
+            exitCode: 2,
+        });
+    }
+    return resolved;
+}
+function assertInputFiles(inputFiles, requiredCode, missingCode) {
+    if (!inputFiles.length) {
+        throw new CliError('At least one input file is required.', {
+            code: requiredCode,
+            exitCode: 2,
+        });
+    }
+    return inputFiles.map((inputFile) => assertInputFile(inputFile, requiredCode, missingCode));
+}
+function assertOutDir(outDir) {
+    if (!outDir) {
+        throw new CliError('Missing required --out-dir value.', {
+            code: 'FLOW_REGEN_OUT_DIR_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return path.resolve(outDir);
+}
+function readJsonObjectFile(filePath, requiredCode, missingCode, invalidCode) {
+    const resolved = assertInputFile(filePath, requiredCode, missingCode);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(resolved, 'utf8'));
+    }
+    catch (error) {
+        throw new CliError(`Expected JSON object file: ${resolved}`, {
+            code: invalidCode,
+            exitCode: 2,
+            details: String(error),
+        });
+    }
+    if (!isRecord(parsed)) {
+        throw new CliError(`Expected JSON object file: ${resolved}`, {
+            code: invalidCode,
+            exitCode: 2,
+        });
+    }
+    return parsed;
+}
+function processDatasetFromRow(row) {
+    const payload = isRecord(row.json_ordered)
+        ? row.json_ordered
+        : isRecord(row.json)
+            ? row.json
+            : row;
+    return isRecord(payload.processDataSet) ? payload.processDataSet : payload;
+}
+function extractProcessIdentity(row) {
+    const dataset = processDatasetFromRow(row);
+    const info = deepGet(dataset, ['processInformation', 'dataSetInformation'], {});
+    const id = coerceText(row.id) || coerceText(info['common:UUID']);
+    const version = coerceText(row.version) ||
+        coerceText(deepGet(dataset, [
+            'administrativeInformation',
+            'publicationAndOwnership',
+            'common:dataSetVersion',
+        ])) ||
+        '01.00.000';
+    const name = coerceText(deepGet(info, ['name', 'baseName']) ?? info.name) || id;
+    return { id, version, name };
+}
+function exchangeRecords(processRow) {
+    const dataset = processDatasetFromRow(processRow);
+    return listify(deepGet(dataset, ['exchanges', 'exchange'], [])).filter(isRecord);
+}
+function extractProcessReferenceExchange(processRow) {
+    const dataset = processDatasetFromRow(processRow);
+    const referenceInternalId = coerceText(deepGet(dataset, ['processInformation', 'quantitativeReference', 'referenceToReferenceFlow']));
+    const exchanges = exchangeRecords(processRow);
+    if (referenceInternalId) {
+        const exact = exchanges.find((exchange) => coerceText(exchange['@dataSetInternalID']) === referenceInternalId);
+        if (exact) {
+            return exact;
+        }
+    }
+    const outputExchange = exchanges.find((exchange) => coerceText(exchange.exchangeDirection).toLowerCase() === 'output');
+    if (outputExchange) {
+        return outputExchange;
+    }
+    return exchanges[0] ?? null;
+}
+function extractReferenceText(ref) {
+    if (!isRecord(ref)) {
+        return coerceText(ref);
+    }
+    return coerceText(ref['common:shortDescription']);
+}
+function extractProcessReferenceFlowRef(processRow) {
+    const exchange = extractProcessReferenceExchange(processRow) ?? {};
+    const ref = isRecord(exchange.referenceToFlowDataSet) ? exchange.referenceToFlowDataSet : {};
+    return {
+        flow_id: coerceText(ref['@refObjectId']),
+        flow_version: coerceText(ref['@version']),
+        flow_text: extractReferenceText(ref),
+        exchange_internal_id: coerceText(exchange['@dataSetInternalID']),
+    };
+}
+function processRowKey(processRow) {
+    const identity = extractProcessIdentity(processRow);
+    if (!identity.id || !identity.version) {
+        return '';
+    }
+    return `${identity.id}@${identity.version}`;
+}
+function versionKey(version) {
+    return String(version)
+        .split('.')
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    });
+}
+function compareVersionKeys(left, right) {
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = left[index] ?? 0;
+        const rightValue = right[index] ?? 0;
+        if (leftValue !== rightValue) {
+            return leftValue - rightValue;
+        }
+    }
+    return 0;
+}
+function processRowSortComparator(left, right) {
+    const leftIdentity = extractProcessIdentity(left);
+    const rightIdentity = extractProcessIdentity(right);
+    const idCompare = leftIdentity.id.localeCompare(rightIdentity.id);
+    if (idCompare !== 0) {
+        return idCompare;
+    }
+    const versionCompare = compareVersionKeys(versionKey(leftIdentity.version), versionKey(rightIdentity.version));
+    if (versionCompare !== 0) {
+        return versionCompare;
+    }
+    return leftIdentity.name.localeCompare(rightIdentity.name);
+}
+function buildFlowIndex(rows) {
+    const byUuid = {};
+    const byUuidVersion = {};
+    const byName = {};
+    const records = [];
+    for (const row of rows) {
+        const record = extractFlowRecord(row);
+        records.push(record);
+        byUuid[record.id] ??= [];
+        byUuid[record.id].push(record);
+        byUuidVersion[`${record.id}@${record.version}`] = record;
+        const normalizedName = normalizeText(record.name);
+        byName[normalizedName] ??= [];
+        byName[normalizedName].push(record);
+    }
+    return {
+        records,
+        byUuid,
+        byUuidVersion,
+        byName,
+    };
+}
+function aliasLookup(aliasMap, flowUuid, flowVersion) {
+    const versionedKey = flowVersion ? `${flowUuid}@${flowVersion}` : null;
+    for (const key of [versionedKey, flowUuid]) {
+        if (!key) {
+            continue;
+        }
+        const candidate = aliasMap[key];
+        if (isRecord(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function buildLocalDatasetUri(datasetKind, uuidValue, version) {
+    if (!uuidValue) {
+        return '';
+    }
+    const folderMap = {
+        flow: 'flows',
+        'flow data set': 'flows',
+    };
+    const folder = folderMap[datasetKind.trim().toLowerCase()] ?? 'datasets';
+    const versionText = version.trim() || '01.00.000';
+    return `../${folder}/${uuidValue}_${versionText}.xml`;
+}
+function preserveShortDescriptionShape(existing, target) {
+    if (Array.isArray(existing)) {
+        if (existing.length > 0 && isRecord(existing[0])) {
+            const patched = cloneJson(existing[0]);
+            patched['@xml:lang'] =
+                coerceText(target['@xml:lang']) || coerceText(patched['@xml:lang']) || 'en';
+            patched['#text'] = coerceText(target['#text']);
+            return [patched];
+        }
+        return [cloneJson(target)];
+    }
+    if (isRecord(existing)) {
+        const patched = cloneJson(existing);
+        patched['@xml:lang'] =
+            coerceText(target['@xml:lang']) || coerceText(patched['@xml:lang']) || 'en';
+        patched['#text'] = coerceText(target['#text']);
+        return patched;
+    }
+    return cloneJson(target);
+}
+function flowReferenceFromRecord(record) {
+    const targetShortDescription = record.shortDescription ??
+        {
+            '@xml:lang': 'en',
+            '#text': record.name,
+        };
+    return {
+        '@type': 'flow data set',
+        '@refObjectId': record.id,
+        '@version': record.version,
+        '@uri': buildLocalDatasetUri('flow data set', record.id, record.version),
+        'common:shortDescription': cloneJson(targetShortDescription),
+    };
+}
+function patchedFlowReference(currentRef, record) {
+    const current = isRecord(currentRef) ? cloneJson(currentRef) : {};
+    const target = flowReferenceFromRecord(record);
+    current['@type'] = coerceText(current['@type']) || coerceText(target['@type']);
+    current['@refObjectId'] = target['@refObjectId'];
+    current['@version'] = target['@version'];
+    current['@uri'] = target['@uri'];
+    current['common:shortDescription'] = preserveShortDescriptionShape(current['common:shortDescription'], target['common:shortDescription']);
+    return current;
+}
+function langEntries(value) {
+    const entries = [];
+    if (Array.isArray(value)) {
+        value.forEach((item) => {
+            entries.push(...langEntries(item));
+        });
+        return entries;
+    }
+    if (!isRecord(value)) {
+        return entries;
+    }
+    if ('#text' in value || '@xml:lang' in value) {
+        const text = coerceText(value['#text']);
+        if (text) {
+            entries.push({
+                lang: coerceText(value['@xml:lang']) || 'en',
+                text,
+            });
+        }
+        return entries;
+    }
+    Object.values(value).forEach((nested) => {
+        entries.push(...langEntries(nested));
+    });
+    return entries;
+}
+function textHasEmergyKeyword(text) {
+    const normalized = normalizeText(text);
+    if (!normalized) {
+        return false;
+    }
+    return EMERGY_TEXT_KEYWORDS.some((keyword) => normalized.includes(normalizeText(keyword)));
+}
+function uniqueNonEmptyTexts(values) {
+    const seen = new Set();
+    const result = [];
+    values.forEach((value) => {
+        const text = String(value || '').trim();
+        if (!text) {
+            return;
+        }
+        const normalized = normalizeText(text);
+        if (seen.has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        result.push(text);
+    });
+    return result;
+}
+function flowEmergyScopeDecision(row) {
+    const record = extractFlowRecord(row);
+    const dataset = flowDatasetFromRow(row);
+    const nameNode = deepGet(dataset, ['flowInformation', 'dataSetInformation', 'name'], {});
+    const nameCandidates = langEntries(nameNode).map((entry) => entry.text);
+    const signals = [];
+    uniqueNonEmptyTexts(nameCandidates).forEach((text) => {
+        if (textHasEmergyKeyword(text)) {
+            signals.push(`emergy_name:${text}`);
+        }
+    });
+    return {
+        entity_type: 'flow',
+        flow_id: record.id,
+        version: record.version,
+        name: record.name,
+        flow_type: record.flowType,
+        excluded: signals.length > 0,
+        reason: signals.length > 0 ? 'emergy_named_flow' : '',
+        signals,
+    };
+}
+function processEmergyScopeDecision(processRow, flowIndex) {
+    const identity = extractProcessIdentity(processRow);
+    const dataset = processDatasetFromRow(processRow);
+    const referenceInfo = extractProcessReferenceFlowRef(processRow);
+    const signals = [];
+    let matchedRecord = flowIndex?.byUuidVersion[`${referenceInfo.flow_id}@${referenceInfo.flow_version}`] ?? null;
+    if (!matchedRecord && flowIndex?.byUuid[referenceInfo.flow_id]?.length) {
+        matchedRecord = flowIndex.byUuid[referenceInfo.flow_id][0] ?? null;
+    }
+    if (matchedRecord) {
+        const flowDecision = flowEmergyScopeDecision(matchedRecord.row);
+        const flowSignals = flowDecision.signals.filter((value) => typeof value === 'string');
+        signals.push(...flowSignals);
+    }
+    if (!signals.length) {
+        const functionalUnitTexts = langEntries(deepGet(dataset, ['processInformation', 'quantitativeReference', 'functionalUnitOrOther'])).map((entry) => entry.text);
+        uniqueNonEmptyTexts([referenceInfo.flow_text, ...functionalUnitTexts]).forEach((text) => {
+            if (textHasEmergyKeyword(text)) {
+                signals.push(`process_ref_text:${text}`);
+            }
+        });
+    }
+    return {
+        entity_type: 'process',
+        process_id: identity.id,
+        process_version: identity.version,
+        process_name: identity.name,
+        reference_flow_id: referenceInfo.flow_id,
+        reference_flow_version: referenceInfo.flow_version,
+        reference_exchange_internal_id: referenceInfo.exchange_internal_id,
+        excluded: signals.length > 0,
+        reason: signals.length > 0 ? 'reference_flow_name_mentions_emergy' : '',
+        signals,
+    };
+}
+function filterEmergyNamedProcesses(rows, flowIndex) {
+    const keptRows = [];
+    const excludedRows = [];
+    rows.forEach((row) => {
+        const decision = processEmergyScopeDecision(row, flowIndex);
+        if (decision.excluded === true) {
+            excludedRows.push(decision);
+            return;
+        }
+        keptRows.push(row);
+    });
+    return {
+        keptRows,
+        excludedRows,
+    };
+}
+function classifyExchangeRef(processRow, exchange, scopeIndex, catalogIndex, aliasMap) {
+    const identity = extractProcessIdentity(processRow);
+    const ref = isRecord(exchange.referenceToFlowDataSet) ? exchange.referenceToFlowDataSet : {};
+    const flowUuid = coerceText(ref['@refObjectId']);
+    const flowVersion = coerceText(ref['@version']);
+    const finding = {
+        process_id: identity.id,
+        process_version: identity.version,
+        process_name: identity.name,
+        exchange_internal_id: coerceText(exchange['@dataSetInternalID']),
+        exchange_direction: exchange.exchangeDirection,
+        reference_flow_id: flowUuid,
+        reference_flow_version: flowVersion,
+        reference_flow_text: extractReferenceText(ref),
+        issue_type: 'exists_in_target',
+        severity: 'info',
+        evidence: {},
+    };
+    if (!flowUuid) {
+        finding.issue_type = 'no_reference';
+        finding.severity = 'error';
+        return finding;
+    }
+    const aliasTarget = aliasLookup(aliasMap, flowUuid, flowVersion || null);
+    if (aliasTarget) {
+        finding.issue_type = 'alias_target_available';
+        finding.severity = 'warning';
+        finding.evidence = {
+            alias_target: aliasTarget,
+        };
+    }
+    if (!flowVersion) {
+        if (scopeIndex.byUuid[flowUuid]?.length) {
+            finding.issue_type = 'version_missing';
+            finding.severity = 'warning';
+            return finding;
+        }
+        if (catalogIndex.byUuid[flowUuid]?.length) {
+            finding.issue_type = 'exists_outside_target';
+            finding.severity = 'warning';
+            return finding;
+        }
+        finding.issue_type = 'missing_uuid';
+        finding.severity = 'error';
+        return finding;
+    }
+    const scopeMatch = scopeIndex.byUuidVersion[`${flowUuid}@${flowVersion}`];
+    if (scopeMatch) {
+        finding.evidence = {
+            scope_group: '',
+            flow_name: scopeMatch.name,
+        };
+        return finding;
+    }
+    if (scopeIndex.byUuid[flowUuid]?.length) {
+        finding.issue_type = 'broken_version';
+        finding.severity = 'error';
+        finding.evidence = {
+            available_versions_in_target: scopeIndex.byUuid[flowUuid]
+                .map((record) => record.version)
+                .sort(),
+        };
+        return finding;
+    }
+    if (catalogIndex.byUuidVersion[`${flowUuid}@${flowVersion}`] ||
+        catalogIndex.byUuid[flowUuid]?.length) {
+        finding.issue_type = 'exists_outside_target';
+        finding.severity = 'warning';
+        return finding;
+    }
+    finding.issue_type = 'missing_uuid';
+    finding.severity = 'error';
+    return finding;
+}
+function buildFindingMap(findings) {
+    const result = {};
+    findings.forEach((finding) => {
+        result[`${finding.process_id}@${finding.process_version}::${finding.exchange_internal_id}`] =
+            finding;
+    });
+    return result;
+}
+function planExchangeRepair(exchange, scopeIndex, aliasMap, finding, autoPatchPolicy) {
+    const ref = isRecord(exchange.referenceToFlowDataSet) ? exchange.referenceToFlowDataSet : {};
+    const flowUuid = coerceText(ref['@refObjectId']);
+    const flowVersion = coerceText(ref['@version']);
+    const exchangeText = extractReferenceText(ref) || coerceText(exchange.exchangeName) || coerceText(exchange.name);
+    const base = {
+        exchange_internal_id: coerceText(exchange['@dataSetInternalID']),
+        current_flow_id: flowUuid,
+        current_flow_version: flowVersion,
+        exchange_direction: exchange.exchangeDirection,
+        exchange_text: exchangeText,
+        current_issue_type: finding?.issue_type,
+        auto_patch_policy: autoPatchPolicy,
+        decision: 'manual_review',
+        reason: 'no_deterministic_match',
+        process_id: '',
+        process_version: '',
+        process_name: '',
+    };
+    if (flowUuid && flowVersion) {
+        const currentRecord = scopeIndex.byUuidVersion[`${flowUuid}@${flowVersion}`];
+        if (currentRecord) {
+            return {
+                ...base,
+                decision: 'keep_as_is',
+                reason: 'already_in_target',
+                target_flow_id: currentRecord.id,
+                target_flow_version: currentRecord.version,
+            };
+        }
+    }
+    const aliasTarget = aliasLookup(aliasMap, flowUuid, flowVersion || null);
+    if (aliasTarget) {
+        const targetRecord = scopeIndex.byUuidVersion[`${coerceText(aliasTarget.id)}@${coerceText(aliasTarget.version)}`];
+        if (targetRecord && autoPatchPolicy !== 'disabled') {
+            return {
+                ...base,
+                decision: 'auto_patch',
+                reason: 'direct_alias_map',
+                target_flow_id: targetRecord.id,
+                target_flow_version: targetRecord.version,
+                target_flow_name: targetRecord.name,
+                target_reference: patchedFlowReference(ref, targetRecord),
+            };
+        }
+        if (targetRecord) {
+            return {
+                ...base,
+                decision: 'manual_review',
+                reason: 'alias_target_found_but_policy_disallows_auto_patch',
+                candidate_count: 1,
+                candidate_refs: [
+                    {
+                        id: targetRecord.id,
+                        version: targetRecord.version,
+                        name: targetRecord.name,
+                    },
+                ],
+            };
+        }
+    }
+    const candidates = scopeIndex.byName[normalizeText(exchangeText)] ?? [];
+    if (candidates.length === 1) {
+        const candidate = candidates[0];
+        if (autoPatchPolicy === 'alias-or-unique-name') {
+            return {
+                ...base,
+                decision: 'auto_patch',
+                reason: 'unique_exact_name_match',
+                target_flow_id: candidate.id,
+                target_flow_version: candidate.version,
+                target_flow_name: candidate.name,
+                target_reference: patchedFlowReference(ref, candidate),
+            };
+        }
+        return {
+            ...base,
+            decision: 'manual_review',
+            reason: 'unique_exact_name_match_blocked_by_policy',
+            candidate_count: 1,
+            candidate_refs: [
+                {
+                    id: candidate.id,
+                    version: candidate.version,
+                    name: candidate.name,
+                },
+            ],
+        };
+    }
+    if (candidates.length > 1) {
+        return {
+            ...base,
+            decision: 'manual_review',
+            reason: 'ambiguous_exact_name_match',
+            candidate_count: candidates.length,
+            candidate_refs: candidates.map((candidate) => ({
+                id: candidate.id,
+                version: candidate.version,
+                name: candidate.name,
+            })),
+        };
+    }
+    return base;
+}
+function buildUnifiedJsonDiff(before, after) {
+    const beforeLines = JSON.stringify(before, null, 2).split('\n');
+    const afterLines = JSON.stringify(after, null, 2).split('\n');
+    if (isDeepStrictEqual(beforeLines, afterLines)) {
+        return '--- before.json\n+++ after.json\n';
+    }
+    let prefix = 0;
+    while (prefix < beforeLines.length &&
+        prefix < afterLines.length &&
+        beforeLines[prefix] === afterLines[prefix]) {
+        prefix += 1;
+    }
+    let beforeSuffix = beforeLines.length - 1;
+    let afterSuffix = afterLines.length - 1;
+    while (beforeSuffix >= prefix &&
+        afterSuffix >= prefix &&
+        beforeLines[beforeSuffix] === afterLines[afterSuffix]) {
+        beforeSuffix -= 1;
+        afterSuffix -= 1;
+    }
+    const beforeChanged = beforeLines.slice(prefix, beforeSuffix + 1);
+    const afterChanged = afterLines.slice(prefix, afterSuffix + 1);
+    const hunkHeader = `@@ -${prefix + 1},${beforeChanged.length} +${prefix + 1},${afterChanged.length} @@`;
+    return [
+        '--- before.json',
+        '+++ after.json',
+        hunkHeader,
+        ...beforeChanged.map((line) => `-${line}`),
+        ...afterChanged.map((line) => `+${line}`),
+        '',
+    ].join('\n');
+}
+function deepDiffPaths(before, after, prefix = []) {
+    if (typeof before !== typeof after || Array.isArray(before) !== Array.isArray(after)) {
+        return [prefix];
+    }
+    if (Array.isArray(before) && Array.isArray(after)) {
+        const paths = [];
+        const maxLength = Math.max(before.length, after.length);
+        for (let index = 0; index < maxLength; index += 1) {
+            if (index >= before.length || index >= after.length) {
+                paths.push([...prefix, index]);
+                continue;
+            }
+            paths.push(...deepDiffPaths(before[index], after[index], [...prefix, index]));
+        }
+        return paths;
+    }
+    if (isRecord(before) && isRecord(after)) {
+        const paths = [];
+        const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+        [...keys].sort().forEach((key) => {
+            if (!(key in before) || !(key in after)) {
+                paths.push([...prefix, key]);
+                return;
+            }
+            paths.push(...deepDiffPaths(before[key], after[key], [...prefix, key]));
+        });
+        return paths;
+    }
+    return isDeepStrictEqual(before, after) ? [] : [prefix];
+}
+function pathContainsReferenceToFlow(pathParts) {
+    return pathParts.includes('referenceToFlowDataSet');
+}
+function safeProcessKey(processId, version) {
+    const versionSlug = version.replace(/[^0-9A-Za-z._-]+/gu, '_') || 'unknown';
+    return `${processId}__${versionSlug}`;
+}
+function writeRowsFile(filePath, rows) {
+    if (filePath.toLowerCase().endsWith('.jsonl')) {
+        return writeJsonLinesArtifact(filePath, rows);
+    }
+    return writeJsonArtifact(filePath, rows);
+}
+function mergeRowsByIdentity(existingRows, incomingRows) {
+    const mergedRows = existingRows.map((row) => cloneJson(row));
+    const keyToIndex = {};
+    mergedRows.forEach((row, index) => {
+        const identity = extractProcessIdentity(row);
+        if (identity.id && identity.version) {
+            keyToIndex[`${identity.id}@${identity.version}`] = index;
+        }
+    });
+    let inserted = 0;
+    let updated = 0;
+    let unchanged = 0;
+    let skippedInvalid = 0;
+    incomingRows.forEach((row) => {
+        const identity = extractProcessIdentity(row);
+        if (!identity.id || !identity.version) {
+            skippedInvalid += 1;
+            return;
+        }
+        const key = `${identity.id}@${identity.version}`;
+        if (!(key in keyToIndex)) {
+            keyToIndex[key] = mergedRows.length;
+            mergedRows.push(cloneJson(row));
+            inserted += 1;
+            return;
+        }
+        const existingIndex = keyToIndex[key];
+        if (isDeepStrictEqual(mergedRows[existingIndex], row)) {
+            unchanged += 1;
+            return;
+        }
+        mergedRows[existingIndex] = cloneJson(row);
+        updated += 1;
+    });
+    return {
+        mergedRows,
+        counts: {
+            inserted,
+            updated,
+            unchanged,
+            skipped_invalid: skippedInvalid,
+        },
+    };
+}
+function syncProcessPoolFile(poolFile, incomingRows) {
+    const poolPath = path.resolve(poolFile);
+    const existingRows = existsSync(poolPath) ? loadRowsFromFile(poolPath) : [];
+    const { mergedRows, counts } = mergeRowsByIdentity(existingRows, incomingRows);
+    mergedRows.sort(processRowSortComparator);
+    writeRowsFile(poolPath, mergedRows);
+    return {
+        pool_file: poolPath,
+        pool_pre_count: existingRows.length,
+        incoming_count: incomingRows.length,
+        pool_post_count: mergedRows.length,
+        ...counts,
+    };
+}
+function resolveProcessValidator(tidasMode, deps) {
+    if (tidasMode === 'skip') {
+        return {
+            createProcess: null,
+            tidasValidation: false,
+        };
+    }
+    try {
+        const module = (deps.loadSdkModule ?? resolveLocalSdkModule)();
+        if (typeof module.createProcess === 'function') {
+            return {
+                createProcess: module.createProcess,
+                tidasValidation: true,
+            };
+        }
+        if (tidasMode === 'required') {
+            throw new CliError('Resolved tidas-sdk core module does not expose createProcess.', {
+                code: 'FLOW_REGEN_PROCESS_SDK_INVALID',
+                exitCode: 2,
+                details: module.location ?? null,
+            });
+        }
+    }
+    catch (error) {
+        if (tidasMode === 'required') {
+            throw error;
+        }
+    }
+    return {
+        createProcess: null,
+        tidasValidation: false,
+    };
+}
+function formatValidationDetails(validation) {
+    if (validation === null || validation === undefined) {
+        return 'Validator returned no result.';
+    }
+    if (validation instanceof Error) {
+        return validation.message;
+    }
+    if (typeof validation === 'string') {
+        return validation;
+    }
+    try {
+        return JSON.stringify(validation);
+    }
+    catch {
+        return String(validation);
+    }
+}
+function evaluateProcessSdkValidation(payload, createProcess) {
+    try {
+        const entity = createProcess(payload, {
+            mode: 'strict',
+            throwOnError: false,
+            deepValidation: true,
+        });
+        const validation = typeof entity?.validateEnhanced === 'function'
+            ? entity.validateEnhanced()
+            : typeof entity?.validate === 'function'
+                ? entity.validate()
+                : null;
+        if (isRecord(validation) && validation.success === true) {
+            return null;
+        }
+        return formatValidationDetails(validation);
+    }
+    catch (error) {
+        return formatValidationDetails(error);
+    }
+}
+function validateProcessPatch(originalRow, patchedRow, scopeIndex, createProcess) {
+    const identity = extractProcessIdentity(patchedRow);
+    const issues = [];
+    if (!originalRow) {
+        issues.push({
+            type: 'missing_original_row',
+            severity: 'error',
+        });
+        return {
+            process_id: identity.id,
+            process_version: identity.version,
+            process_name: identity.name,
+            ok: false,
+            issues,
+        };
+    }
+    const illegalPaths = deepDiffPaths(originalRow, patchedRow).filter((pathParts) => !pathContainsReferenceToFlow(pathParts));
+    if (illegalPaths.length > 0) {
+        issues.push({
+            type: 'non_reference_changes_detected',
+            severity: 'error',
+            paths: illegalPaths.map((pathParts) => pathParts.map((part) => String(part)).join('.')),
+        });
+    }
+    const originalQuantitativeReference = coerceText(deepGet(processDatasetFromRow(originalRow), [
+        'processInformation',
+        'quantitativeReference',
+        'referenceToReferenceFlow',
+    ]));
+    const patchedQuantitativeReference = coerceText(deepGet(processDatasetFromRow(patchedRow), [
+        'processInformation',
+        'quantitativeReference',
+        'referenceToReferenceFlow',
+    ]));
+    if (originalQuantitativeReference !== patchedQuantitativeReference) {
+        issues.push({
+            type: 'quantitative_reference_changed',
+            severity: 'error',
+            before: originalQuantitativeReference,
+            after: patchedQuantitativeReference,
+        });
+    }
+    const originalExchangeCount = exchangeRecords(originalRow).length;
+    const patchedExchangeCount = exchangeRecords(patchedRow).length;
+    if (originalExchangeCount !== patchedExchangeCount) {
+        issues.push({
+            type: 'exchange_count_changed',
+            severity: 'error',
+            before: originalExchangeCount,
+            after: patchedExchangeCount,
+        });
+    }
+    exchangeRecords(patchedRow).forEach((exchange) => {
+        const ref = isRecord(exchange.referenceToFlowDataSet) ? exchange.referenceToFlowDataSet : {};
+        const flowId = coerceText(ref['@refObjectId']);
+        const flowVersion = coerceText(ref['@version']);
+        if (!flowId || !flowVersion) {
+            issues.push({
+                type: 'missing_flow_reference_after_patch',
+                severity: 'error',
+                exchange_internal_id: coerceText(exchange['@dataSetInternalID']),
+                flow_id: flowId,
+                flow_version: flowVersion,
+            });
+            return;
+        }
+        if (!scopeIndex.byUuidVersion[`${flowId}@${flowVersion}`]) {
+            issues.push({
+                type: 'patched_reference_not_in_scope_catalog',
+                severity: 'error',
+                exchange_internal_id: coerceText(exchange['@dataSetInternalID']),
+                flow_id: flowId,
+                flow_version: flowVersion,
+            });
+        }
+    });
+    if (createProcess) {
+        const details = evaluateProcessSdkValidation(processDatasetFromRow(patchedRow), createProcess);
+        if (details !== null) {
+            issues.push({
+                type: 'tidas_validation_failed',
+                severity: 'error',
+                details,
+            });
+        }
+    }
+    return {
+        process_id: identity.id,
+        process_version: identity.version,
+        process_name: identity.name,
+        ok: issues.length === 0,
+        issues,
+    };
+}
+function buildScanStageFiles(outDir) {
+    return {
+        out_dir: outDir,
+        emergy_excluded_processes: path.join(outDir, 'emergy-excluded-processes.json'),
+        summary: path.join(outDir, 'scan-summary.json'),
+        findings: path.join(outDir, 'scan-findings.json'),
+        findings_jsonl: path.join(outDir, 'scan-findings.jsonl'),
+    };
+}
+function buildRepairStageFiles(outDir) {
+    return {
+        out_dir: outDir,
+        plan: path.join(outDir, 'repair-plan.json'),
+        plan_jsonl: path.join(outDir, 'repair-plan.jsonl'),
+        manual_review_queue: path.join(outDir, 'manual-review-queue.jsonl'),
+        summary: path.join(outDir, 'repair-summary.json'),
+    };
+}
+function buildApplyStageFiles(outDir) {
+    return {
+        ...buildRepairStageFiles(outDir),
+        patched_processes: path.join(outDir, 'patched-processes.json'),
+        patch_root: path.join(outDir, 'process-patches'),
+    };
+}
+function buildValidateStageFiles(outDir) {
+    return {
+        out_dir: outDir,
+        report: path.join(outDir, 'validation-report.json'),
+        failures: path.join(outDir, 'validation-failures.jsonl'),
+    };
+}
+function loadOptionalScanFindings(scanFindingsFile, requiredCode, missingCode) {
+    if (!scanFindingsFile) {
+        return {
+            resolvedFile: null,
+            scanFindings: [],
+        };
+    }
+    const resolvedFile = assertInputFile(scanFindingsFile, requiredCode, missingCode);
+    return {
+        resolvedFile,
+        scanFindings: loadRowsFromFile(resolvedFile),
+    };
+}
+function runScanStage(processes, scopeIndex, catalogIndex, aliasMap, outDir, excludeEmergy) {
+    const files = buildScanStageFiles(outDir);
+    const { keptRows, excludedRows } = excludeEmergy
+        ? filterEmergyNamedProcesses(processes, catalogIndex)
+        : { keptRows: processes, excludedRows: [] };
+    const findings = [];
+    const issueProcessKeys = new Set();
+    const issueCounts = {};
+    let exchangeCount = 0;
+    keptRows.forEach((processRow) => {
+        const identity = extractProcessIdentity(processRow);
+        const exchanges = exchangeRecords(processRow);
+        exchangeCount += exchanges.length;
+        exchanges.forEach((exchange) => {
+            const finding = classifyExchangeRef(processRow, exchange, scopeIndex, catalogIndex, aliasMap);
+            findings.push(finding);
+            issueCounts[finding.issue_type] = (issueCounts[finding.issue_type] ?? 0) + 1;
+            if (finding.issue_type !== 'exists_in_target') {
+                issueProcessKeys.add(`${identity.id}@${identity.version}`);
+            }
+        });
+    });
+    const summary = {
+        process_count_before_emergy_exclusion: processes.length,
+        process_count: keptRows.length,
+        emergy_excluded_process_count: excludedRows.length,
+        exchange_count: exchangeCount,
+        issue_counts: issueCounts,
+        processes_with_issues: issueProcessKeys.size,
+    };
+    writeJsonArtifact(files.emergy_excluded_processes, excludedRows);
+    writeJsonArtifact(files.summary, summary);
+    writeJsonArtifact(files.findings, findings);
+    writeJsonLinesArtifact(files.findings_jsonl, findings);
+    return {
+        filteredProcesses: keptRows,
+        emergyExcludedProcesses: excludedRows,
+        findings,
+        summary,
+        files,
+    };
+}
+function runRepairStage(options) {
+    const files = options.apply
+        ? buildApplyStageFiles(options.outDir)
+        : buildRepairStageFiles(options.outDir);
+    const findingMap = buildFindingMap(options.scanFindings);
+    const repairPlan = [];
+    const manualQueue = [];
+    const patchedRows = [];
+    const decisionCounts = {};
+    options.processes.forEach((processRow) => {
+        const identity = extractProcessIdentity(processRow);
+        const processKey = `${identity.id}@${identity.version}`;
+        const workingRow = options.apply ? cloneJson(processRow) : processRow;
+        const processPlan = [];
+        let changed = false;
+        exchangeRecords(workingRow).forEach((exchange) => {
+            const action = planExchangeRepair(exchange, options.scopeIndex, options.aliasMap, findingMap[`${processKey}::${coerceText(exchange['@dataSetInternalID'])}`] ?? null, options.autoPatchPolicy);
+            action.process_id = identity.id;
+            action.process_version = identity.version;
+            action.process_name = identity.name;
+            processPlan.push(action);
+            repairPlan.push(action);
+            decisionCounts[action.decision] = (decisionCounts[action.decision] ?? 0) + 1;
+            if (action.decision === 'manual_review') {
+                manualQueue.push(action);
+            }
+            if (options.apply && action.decision === 'auto_patch' && isRecord(action.target_reference)) {
+                exchange.referenceToFlowDataSet = cloneJson(action.target_reference);
+                changed = true;
+            }
+        });
+        if (options.apply && changed) {
+            patchedRows.push(workingRow);
+            const patchRoot = files.patch_root;
+            const processDir = path.join(patchRoot, safeProcessKey(identity.id, identity.version));
+            writeJsonArtifact(path.join(processDir, 'before.json'), processRow);
+            writeJsonArtifact(path.join(processDir, 'after.json'), workingRow);
+            writeJsonArtifact(path.join(processDir, 'evidence.json'), processPlan.filter((item) => item.decision === 'auto_patch'));
+            writeTextArtifact(path.join(processDir, 'diff.patch'), buildUnifiedJsonDiff(processRow, workingRow));
+        }
+    });
+    const summary = {
+        auto_patch_policy: options.autoPatchPolicy,
+        process_count: options.processes.length,
+        repair_item_count: repairPlan.length,
+        decision_counts: decisionCounts,
+        patched_process_count: options.apply ? patchedRows.length : 0,
+    };
+    if (options.apply && options.processPoolFile) {
+        summary.process_pool_sync = syncProcessPoolFile(options.processPoolFile, patchedRows);
+    }
+    writeJsonArtifact(files.plan, repairPlan);
+    writeJsonLinesArtifact(files.plan_jsonl, repairPlan);
+    writeJsonLinesArtifact(files.manual_review_queue, manualQueue);
+    writeJsonArtifact(files.summary, summary);
+    if (options.apply) {
+        writeJsonArtifact(files.patched_processes, patchedRows);
+    }
+    return {
+        plan: repairPlan,
+        manualQueue,
+        summary,
+        files,
+        patchedRows,
+    };
+}
+function runValidateStage(options) {
+    const files = buildValidateStageFiles(options.outDir);
+    const validator = resolveProcessValidator(options.tidasMode, options.deps);
+    const originalMap = {};
+    options.originalRows.forEach((row) => {
+        const key = processRowKey(row);
+        if (key) {
+            originalMap[key] = row;
+        }
+    });
+    const results = options.patchedRows.map((patchedRow) => {
+        const key = processRowKey(patchedRow);
+        return validateProcessPatch(key ? (originalMap[key] ?? null) : null, patchedRow, options.scopeIndex, validator.createProcess ?? null);
+    });
+    const failures = results.filter((result) => !result.ok);
+    const summary = {
+        patched_process_count: options.patchedRows.length,
+        passed: results.length - failures.length,
+        failed: failures.length,
+        tidas_validation: validator.tidasValidation,
+    };
+    const report = {
+        summary,
+        results,
+    };
+    writeJsonArtifact(files.report, report);
+    writeJsonLinesArtifact(files.failures, failures);
+    return {
+        summary,
+        results,
+        failures,
+        files,
+    };
+}
+export async function runFlowScanProcessFlowRefs(options, deps = {}) {
+    const processesFile = assertInputFile(options.processesFile, 'FLOW_SCAN_PROCESS_FLOW_REFS_PROCESSES_FILE_REQUIRED', 'FLOW_SCAN_PROCESS_FLOW_REFS_PROCESSES_FILE_NOT_FOUND');
+    const scopeFlowFiles = assertInputFiles(options.scopeFlowFiles ?? [], 'FLOW_SCAN_PROCESS_FLOW_REFS_SCOPE_FLOW_FILES_REQUIRED', 'FLOW_SCAN_PROCESS_FLOW_REFS_SCOPE_FLOW_FILE_NOT_FOUND');
+    const catalogFlowFiles = options.catalogFlowFiles && options.catalogFlowFiles.length > 0
+        ? assertInputFiles(options.catalogFlowFiles, 'FLOW_SCAN_PROCESS_FLOW_REFS_CATALOG_FLOW_FILES_REQUIRED', 'FLOW_SCAN_PROCESS_FLOW_REFS_CATALOG_FLOW_FILE_NOT_FOUND')
+        : scopeFlowFiles;
+    const aliasMapFile = options.aliasMapFile
+        ? assertInputFile(options.aliasMapFile, 'FLOW_SCAN_PROCESS_FLOW_REFS_ALIAS_MAP_REQUIRED', 'FLOW_SCAN_PROCESS_FLOW_REFS_ALIAS_MAP_NOT_FOUND')
+        : null;
+    const outDir = assertOutDir(options.outDir);
+    const now = deps.now ?? (() => new Date());
+    const processes = loadRowsFromFile(processesFile);
+    const scopeRows = scopeFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const catalogRows = catalogFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const aliasMap = aliasMapFile
+        ? readJsonObjectFile(aliasMapFile, 'FLOW_SCAN_PROCESS_FLOW_REFS_ALIAS_MAP_REQUIRED', 'FLOW_SCAN_PROCESS_FLOW_REFS_ALIAS_MAP_NOT_FOUND', 'FLOW_SCAN_PROCESS_FLOW_REFS_ALIAS_MAP_INVALID')
+        : {};
+    const scopeIndex = buildFlowIndex(scopeRows);
+    const catalogIndex = buildFlowIndex(catalogRows);
+    const scanStage = runScanStage(processes, scopeIndex, catalogIndex, aliasMap, outDir, options.excludeEmergy === true);
+    return {
+        schema_version: 1,
+        generated_at_utc: now().toISOString(),
+        status: 'completed_local_flow_scan_process_flow_refs',
+        processes_file: processesFile,
+        scope_flow_files: scopeFlowFiles,
+        catalog_flow_files: catalogFlowFiles,
+        alias_map_file: aliasMapFile,
+        exclude_emergy: options.excludeEmergy === true,
+        out_dir: outDir,
+        summary: scanStage.summary,
+        files: scanStage.files,
+    };
+}
+export async function runFlowPlanProcessFlowRepairs(options, deps = {}) {
+    const processesFile = assertInputFile(options.processesFile, 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_PROCESSES_FILE_REQUIRED', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_PROCESSES_FILE_NOT_FOUND');
+    const scopeFlowFiles = assertInputFiles(options.scopeFlowFiles ?? [], 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_SCOPE_FLOW_FILES_REQUIRED', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_SCOPE_FLOW_FILE_NOT_FOUND');
+    const aliasMapFile = options.aliasMapFile
+        ? assertInputFile(options.aliasMapFile, 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_ALIAS_MAP_REQUIRED', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_ALIAS_MAP_NOT_FOUND')
+        : null;
+    const { resolvedFile: scanFindingsFile, scanFindings } = loadOptionalScanFindings(options.scanFindingsFile ?? null, 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_SCAN_FINDINGS_REQUIRED', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_SCAN_FINDINGS_NOT_FOUND');
+    const outDir = assertOutDir(options.outDir);
+    const autoPatchPolicy = options.autoPatchPolicy ?? 'alias-only';
+    const now = deps.now ?? (() => new Date());
+    const processes = loadRowsFromFile(processesFile);
+    const scopeRows = scopeFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const aliasMap = aliasMapFile
+        ? readJsonObjectFile(aliasMapFile, 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_ALIAS_MAP_REQUIRED', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_ALIAS_MAP_NOT_FOUND', 'FLOW_PLAN_PROCESS_FLOW_REPAIRS_ALIAS_MAP_INVALID')
+        : {};
+    const scopeIndex = buildFlowIndex(scopeRows);
+    const repairStage = runRepairStage({
+        processes,
+        scopeIndex,
+        aliasMap,
+        scanFindings,
+        autoPatchPolicy,
+        outDir,
+        apply: false,
+        processPoolFile: null,
+    });
+    return {
+        schema_version: 1,
+        generated_at_utc: now().toISOString(),
+        status: 'completed_local_flow_plan_process_flow_repairs',
+        processes_file: processesFile,
+        scope_flow_files: scopeFlowFiles,
+        alias_map_file: aliasMapFile,
+        scan_findings_file: scanFindingsFile,
+        auto_patch_policy: autoPatchPolicy,
+        out_dir: outDir,
+        summary: repairStage.summary,
+        files: repairStage.files,
+    };
+}
+export async function runFlowApplyProcessFlowRepairs(options, deps = {}) {
+    const processesFile = assertInputFile(options.processesFile, 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_PROCESSES_FILE_REQUIRED', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_PROCESSES_FILE_NOT_FOUND');
+    const scopeFlowFiles = assertInputFiles(options.scopeFlowFiles ?? [], 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_SCOPE_FLOW_FILES_REQUIRED', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_SCOPE_FLOW_FILE_NOT_FOUND');
+    const aliasMapFile = options.aliasMapFile
+        ? assertInputFile(options.aliasMapFile, 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_ALIAS_MAP_REQUIRED', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_ALIAS_MAP_NOT_FOUND')
+        : null;
+    const { resolvedFile: scanFindingsFile, scanFindings } = loadOptionalScanFindings(options.scanFindingsFile ?? null, 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_SCAN_FINDINGS_REQUIRED', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_SCAN_FINDINGS_NOT_FOUND');
+    const outDir = assertOutDir(options.outDir);
+    const autoPatchPolicy = options.autoPatchPolicy ?? 'alias-only';
+    const processPoolFile = options.processPoolFile ? path.resolve(options.processPoolFile) : null;
+    const now = deps.now ?? (() => new Date());
+    const processes = loadRowsFromFile(processesFile);
+    const scopeRows = scopeFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const aliasMap = aliasMapFile
+        ? readJsonObjectFile(aliasMapFile, 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_ALIAS_MAP_REQUIRED', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_ALIAS_MAP_NOT_FOUND', 'FLOW_APPLY_PROCESS_FLOW_REPAIRS_ALIAS_MAP_INVALID')
+        : {};
+    const scopeIndex = buildFlowIndex(scopeRows);
+    const repairStage = runRepairStage({
+        processes,
+        scopeIndex,
+        aliasMap,
+        scanFindings,
+        autoPatchPolicy,
+        outDir,
+        apply: true,
+        processPoolFile,
+    });
+    return {
+        schema_version: 1,
+        generated_at_utc: now().toISOString(),
+        status: 'completed_local_flow_apply_process_flow_repairs',
+        processes_file: processesFile,
+        scope_flow_files: scopeFlowFiles,
+        alias_map_file: aliasMapFile,
+        scan_findings_file: scanFindingsFile,
+        auto_patch_policy: autoPatchPolicy,
+        process_pool_file: processPoolFile,
+        out_dir: outDir,
+        summary: repairStage.summary,
+        files: repairStage.files,
+    };
+}
+function buildReportFiles(outDir, apply) {
+    return {
+        report: path.join(outDir, 'flow-regen-product-report.json'),
+        scan: buildScanStageFiles(path.join(outDir, 'scan')),
+        repair: buildRepairStageFiles(path.join(outDir, 'repair')),
+        apply: apply ? buildApplyStageFiles(path.join(outDir, 'repair-apply')) : null,
+        validate: apply ? buildValidateStageFiles(path.join(outDir, 'validate')) : null,
+    };
+}
+export async function runFlowRegenProduct(options, deps = {}) {
+    const processesFile = assertInputFile(options.processesFile, 'FLOW_REGEN_PROCESSES_FILE_REQUIRED', 'FLOW_REGEN_PROCESSES_FILE_NOT_FOUND');
+    const scopeFlowFiles = assertInputFiles(options.scopeFlowFiles ?? [], 'FLOW_REGEN_SCOPE_FLOW_FILES_REQUIRED', 'FLOW_REGEN_SCOPE_FLOW_FILE_NOT_FOUND');
+    const catalogFlowFiles = options.catalogFlowFiles && options.catalogFlowFiles.length > 0
+        ? assertInputFiles(options.catalogFlowFiles, 'FLOW_REGEN_CATALOG_FLOW_FILE_REQUIRED', 'FLOW_REGEN_CATALOG_FLOW_FILE_NOT_FOUND')
+        : scopeFlowFiles;
+    const aliasMapFile = options.aliasMapFile
+        ? assertInputFile(options.aliasMapFile, 'FLOW_REGEN_ALIAS_MAP_REQUIRED', 'FLOW_REGEN_ALIAS_MAP_NOT_FOUND')
+        : null;
+    const outDir = assertOutDir(options.outDir);
+    const processPoolFile = options.processPoolFile ? path.resolve(options.processPoolFile) : null;
+    const apply = options.apply === true;
+    const autoPatchPolicy = options.autoPatchPolicy ?? 'alias-only';
+    const tidasMode = options.tidasMode ?? 'auto';
+    const files = buildReportFiles(outDir, apply);
+    const now = deps.now ?? (() => new Date());
+    const processes = loadRowsFromFile(processesFile);
+    const scopeRows = scopeFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const catalogRows = catalogFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const aliasMap = aliasMapFile
+        ? readJsonObjectFile(aliasMapFile, 'FLOW_REGEN_ALIAS_MAP_REQUIRED', 'FLOW_REGEN_ALIAS_MAP_NOT_FOUND', 'FLOW_REGEN_ALIAS_MAP_INVALID')
+        : {};
+    const scopeIndex = buildFlowIndex(scopeRows);
+    const catalogIndex = buildFlowIndex(catalogRows);
+    const scanStage = runScanStage(processes, scopeIndex, catalogIndex, aliasMap, files.scan.out_dir, options.excludeEmergy === true);
+    const repairStage = runRepairStage({
+        processes: scanStage.filteredProcesses,
+        scopeIndex,
+        aliasMap,
+        scanFindings: scanStage.findings,
+        autoPatchPolicy,
+        outDir: files.repair.out_dir,
+        apply: false,
+        processPoolFile: null,
+    });
+    const applyStage = apply
+        ? runRepairStage({
+            processes: scanStage.filteredProcesses,
+            scopeIndex,
+            aliasMap,
+            scanFindings: scanStage.findings,
+            autoPatchPolicy,
+            outDir: files.apply.out_dir,
+            apply: true,
+            processPoolFile,
+        })
+        : null;
+    const validateStage = apply && applyStage
+        ? runValidateStage({
+            originalRows: scanStage.filteredProcesses,
+            patchedRows: applyStage.patchedRows,
+            scopeIndex,
+            outDir: files.validate.out_dir,
+            tidasMode,
+            deps,
+        })
+        : null;
+    const report = {
+        schema_version: 1,
+        generated_at_utc: now().toISOString(),
+        status: 'completed_local_flow_regen_product',
+        mode: apply ? 'apply' : 'plan',
+        processes_file: processesFile,
+        scope_flow_files: scopeFlowFiles,
+        catalog_flow_files: catalogFlowFiles,
+        alias_map_file: aliasMapFile,
+        exclude_emergy: options.excludeEmergy === true,
+        auto_patch_policy: autoPatchPolicy,
+        process_pool_file: processPoolFile,
+        tidas_mode: tidasMode,
+        out_dir: outDir,
+        counts: {
+            process_count_before_emergy_exclusion: scanStage.summary.process_count_before_emergy_exclusion,
+            process_count: scanStage.summary.process_count,
+            emergy_excluded_process_count: scanStage.summary.emergy_excluded_process_count,
+            exchange_count: scanStage.summary.exchange_count,
+            issue_counts: scanStage.summary.issue_counts,
+            processes_with_issues: scanStage.summary.processes_with_issues,
+            repair_item_count: repairStage.summary.repair_item_count,
+            decision_counts: repairStage.summary.decision_counts,
+            patched_process_count: applyStage?.summary.patched_process_count ?? 0,
+            validation_passed_count: validateStage?.summary.passed ?? null,
+            validation_failed_count: validateStage?.summary.failed ?? null,
+        },
+        validation: {
+            enabled: apply,
+            tidas_validation: validateStage?.summary.tidas_validation ?? false,
+            ok: validateStage ? validateStage.summary.failed === 0 : null,
+        },
+        files,
+    };
+    writeJsonArtifact(files.report, report);
+    return report;
+}
+export async function runFlowValidateProcesses(options, deps = {}) {
+    const originalProcessesFile = assertInputFile(options.originalProcessesFile, 'FLOW_VALIDATE_PROCESSES_ORIGINAL_FILE_REQUIRED', 'FLOW_VALIDATE_PROCESSES_ORIGINAL_FILE_NOT_FOUND');
+    const patchedProcessesFile = assertInputFile(options.patchedProcessesFile, 'FLOW_VALIDATE_PROCESSES_PATCHED_FILE_REQUIRED', 'FLOW_VALIDATE_PROCESSES_PATCHED_FILE_NOT_FOUND');
+    const scopeFlowFiles = assertInputFiles(options.scopeFlowFiles ?? [], 'FLOW_VALIDATE_PROCESSES_SCOPE_FLOW_FILES_REQUIRED', 'FLOW_VALIDATE_PROCESSES_SCOPE_FLOW_FILE_NOT_FOUND');
+    const outDir = assertOutDir(options.outDir);
+    const tidasMode = options.tidasMode ?? 'auto';
+    const now = deps.now ?? (() => new Date());
+    const originalRows = loadRowsFromFile(originalProcessesFile);
+    const patchedRows = loadRowsFromFile(patchedProcessesFile);
+    const scopeRows = scopeFlowFiles.flatMap((filePath) => loadRowsFromFile(filePath));
+    const scopeIndex = buildFlowIndex(scopeRows);
+    const validateStage = runValidateStage({
+        originalRows,
+        patchedRows,
+        scopeIndex,
+        outDir,
+        tidasMode,
+        deps,
+    });
+    return {
+        schema_version: 1,
+        generated_at_utc: now().toISOString(),
+        status: 'completed_local_flow_validate_processes',
+        original_processes_file: originalProcessesFile,
+        patched_processes_file: patchedProcessesFile,
+        scope_flow_files: scopeFlowFiles,
+        out_dir: outDir,
+        tidas_mode: tidasMode,
+        summary: validateStage.summary,
+        files: validateStage.files,
+        results: validateStage.results,
+    };
+}
+export const __testInternals = {
+    resolveCliRepoRoot,
+    assertInputFile,
+    assertInputFiles,
+    assertOutDir,
+    readJsonObjectFile,
+    resolveLocalSdkModule,
+    processDatasetFromRow,
+    extractProcessIdentity,
+    exchangeRecords,
+    extractProcessReferenceExchange,
+    extractReferenceText,
+    extractProcessReferenceFlowRef,
+    processRowKey,
+    versionKey,
+    compareVersionKeys,
+    processRowSortComparator,
+    buildFlowIndex,
+    aliasLookup,
+    buildLocalDatasetUri,
+    preserveShortDescriptionShape,
+    flowReferenceFromRecord,
+    patchedFlowReference,
+    langEntries,
+    textHasEmergyKeyword,
+    uniqueNonEmptyTexts,
+    flowEmergyScopeDecision,
+    processEmergyScopeDecision,
+    filterEmergyNamedProcesses,
+    classifyExchangeRef,
+    buildFindingMap,
+    planExchangeRepair,
+    buildUnifiedJsonDiff,
+    deepDiffPaths,
+    pathContainsReferenceToFlow,
+    safeProcessKey,
+    writeRowsFile,
+    mergeRowsByIdentity,
+    syncProcessPoolFile,
+    buildSdkCandidates,
+    resolveSdkModuleFromCandidates,
+    resolveProcessValidator,
+    formatValidationDetails,
+    evaluateProcessSdkValidation,
+    validateProcessPatch,
+    buildScanStageFiles,
+    buildRepairStageFiles,
+    buildApplyStageFiles,
+    buildValidateStageFiles,
+    runScanStage,
+    runRepairStage,
+    runValidateStage,
+    buildReportFiles,
+};
+//# sourceMappingURL=flow-regen-product.js.map