@tiangong-lca/cli 0.0.7 → 0.0.9

package/dist/src/lib/dataset-author.js

@@ -0,0 +1,100 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { writeJsonArtifact } from './artifacts.js';
+import { runDatasetContract } from './dataset-contract.js';
+import { CliError } from './errors.js';
+import { parseUnstructuredDocument, readUnstructuredRuntimeEnv, } from './unstructured.js';
+export async function runDatasetAuthor(options) {
+    const inputPath = requireInputPath(options.inputPath);
+    const outDir = requireOutDir(options.outDir);
+    const targetTypes = normalizeTargetTypes(options.targetTypes);
+    const outputsDir = path.join(outDir, 'outputs');
+    const sourceExtractFile = path.join(outputsDir, 'source-extract.json');
+    const authoringReportFile = path.join(outputsDir, 'authoring-report.json');
+    const parseImpl = options.parseImpl ?? parseUnstructuredDocument;
+    const contractImpl = options.contractImpl ?? runDatasetContract;
+    const sourceExtract = await parseImpl({
+        env: readUnstructuredRuntimeEnv(options.env),
+        filePath: inputPath,
+        prompt: options.prompt,
+        provider: options.provider,
+        model: options.model,
+        timeoutMs: options.timeoutMs ?? 120000,
+        fetchImpl: options.fetchImpl,
+    });
+    writeJsonArtifact(sourceExtractFile, sourceExtract);
+    const contextPacks = [];
+    for (const type of targetTypes) {
+        const report = await contractImpl({
+            type,
+            include: ['schema', 'methodology', 'ruleset'],
+            profile: 'ai-import',
+            outDir: path.join(outDir, 'context', type),
+            mode: 'context-pack',
+            now: options.now,
+        });
+        contextPacks.push({ type, report });
+    }
+    const report = {
+        schema_version: 1,
+        status: 'evidence_ready',
+        generated_at_utc: (options.now ?? new Date()).toISOString(),
+        input_path: inputPath,
+        target_types: targetTypes,
+        files: {
+            source_extract: sourceExtractFile,
+            authoring_report: authoringReportFile,
+        },
+        context_packs: contextPacks,
+        next_actions: [
+            'Use outputs/source-extract.json and the context pack manifests to generate candidate TIDAS rows.',
+            'Run tiangong-lca dataset validate for each generated row file before mutation planning.',
+            'Place invalid rows in a repair queue and keep source evidence linked to field-level assumptions.',
+        ],
+    };
+    writeJsonArtifact(authoringReportFile, report);
+    return report;
+}
+function requireInputPath(value) {
+    if (!value?.trim()) {
+        throw new CliError('Missing required --input value.', {
+            code: 'DATASET_AUTHOR_INPUT_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    const resolved = path.resolve(value);
+    if (!existsSync(resolved)) {
+        throw new CliError(`Input file not found: ${resolved}`, {
+            code: 'DATASET_AUTHOR_INPUT_NOT_FOUND',
+            exitCode: 2,
+        });
+    }
+    return resolved;
+}
+function requireOutDir(value) {
+    if (!value?.trim()) {
+        throw new CliError('Missing required --out-dir value.', {
+            code: 'DATASET_AUTHOR_OUT_DIR_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return path.resolve(value);
+}
+function normalizeTargetTypes(value) {
+    const rawValues = Array.isArray(value) ? value : value ? [value] : [];
+    const values = rawValues.flatMap((item) => item
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean));
+    if (!values.length) {
+        throw new CliError('Missing required --target-types value.', {
+            code: 'DATASET_AUTHOR_TARGET_TYPES_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return [...new Set(values)];
+}
+export const __testInternals = {
+    normalizeTargetTypes,
+};
+//# sourceMappingURL=dataset-author.js.map

package/dist/src/lib/dataset-author.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-author.js","sourceRoot":"","sources":["../../../src/lib/dataset-author.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from 'node:fs';\nimport path from 'node:path';\nimport { writeJsonArtifact } from './artifacts.js';\nimport { runDatasetContract, type DatasetContractReport } from './dataset-contract.js';\nimport { CliError } from './errors.js';\nimport {\n  parseUnstructuredDocument,\n  readUnstructuredRuntimeEnv,\n  type ParseUnstructuredDocumentOptions,\n} from './unstructured.js';\nimport type { FetchLike } from './http.js';\n\nexport type DatasetAuthorReport = {\n  schema_version: 1;\n  status: 'evidence_ready';\n  generated_at_utc: string;\n  input_path: string;\n  target_types: string[];\n  files: {\n    source_extract: string;\n    authoring_report: string;\n  };\n  context_packs: Array<{\n    type: string;\n    report: DatasetContractReport;\n  }>;\n  next_actions: string[];\n};\n\nexport type RunDatasetAuthorOptions = {\n  inputPath: string;\n  targetTypes: string | string[] | undefined;\n  outDir: string | null | undefined;\n  prompt?: string | undefined;\n  provider?: string | undefined;\n  model?: string | undefined;\n  timeoutMs?: number | undefined;\n  env: NodeJS.ProcessEnv;\n  fetchImpl: FetchLike;\n  now?: Date | undefined;\n  parseImpl?: typeof parseUnstructuredDocument | undefined;\n  contractImpl?: typeof runDatasetContract | undefined;\n};\n\nexport async function runDatasetAuthor(\n  options: RunDatasetAuthorOptions,\n): Promise<DatasetAuthorReport> {\n  const inputPath = requireInputPath(options.inputPath);\n  const outDir = requireOutDir(options.outDir);\n  const targetTypes = normalizeTargetTypes(options.targetTypes);\n  const outputsDir = path.join(outDir, 'outputs');\n  const sourceExtractFile = path.join(outputsDir, 'source-extract.json');\n  const authoringReportFile = path.join(outputsDir, 'authoring-report.json');\n  const parseImpl = options.parseImpl ?? parseUnstructuredDocument;\n  const contractImpl = options.contractImpl ?? runDatasetContract;\n\n  const sourceExtract = await parseImpl({\n    env: readUnstructuredRuntimeEnv(options.env),\n    filePath: inputPath,\n    prompt: options.prompt,\n    provider: options.provider,\n    model: options.model,\n    timeoutMs: options.timeoutMs ?? 120000,\n    fetchImpl: options.fetchImpl,\n  } satisfies ParseUnstructuredDocumentOptions);\n  writeJsonArtifact(sourceExtractFile, sourceExtract);\n\n  const contextPacks = [];\n  for (const type of targetTypes) {\n    const report = await contractImpl({\n      type,\n      include: ['schema', 'methodology', 'ruleset'],\n      profile: 'ai-import',\n      outDir: path.join(outDir, 'context', type),\n      mode: 'context-pack',\n      now: options.now,\n    });\n    contextPacks.push({ type, report });\n  }\n\n  const report: DatasetAuthorReport = {\n    schema_version: 1,\n    status: 'evidence_ready',\n    generated_at_utc: (options.now ?? new Date()).toISOString(),\n    input_path: inputPath,\n    target_types: targetTypes,\n    files: {\n      source_extract: sourceExtractFile,\n      authoring_report: authoringReportFile,\n    },\n    context_packs: contextPacks,\n    next_actions: [\n      'Use outputs/source-extract.json and the context pack manifests to generate candidate TIDAS rows.',\n      'Run tiangong-lca dataset validate for each generated row file before mutation planning.',\n      'Place invalid rows in a repair queue and keep source evidence linked to field-level assumptions.',\n    ],\n  };\n  writeJsonArtifact(authoringReportFile, report);\n\n  return report;\n}\n\nfunction requireInputPath(value: string): string {\n  if (!value?.trim()) {\n    throw new CliError('Missing required --input value.', {\n      code: 'DATASET_AUTHOR_INPUT_REQUIRED',\n      exitCode: 2,\n    });\n  }\n  const resolved = path.resolve(value);\n  if (!existsSync(resolved)) {\n    throw new CliError(`Input file not found: ${resolved}`, {\n      code: 'DATASET_AUTHOR_INPUT_NOT_FOUND',\n      exitCode: 2,\n    });\n  }\n  return resolved;\n}\n\nfunction requireOutDir(value: string | null | undefined): string {\n  if (!value?.trim()) {\n    throw new CliError('Missing required --out-dir value.', {\n      code: 'DATASET_AUTHOR_OUT_DIR_REQUIRED',\n      exitCode: 2,\n    });\n  }\n  return path.resolve(value);\n}\n\nfunction normalizeTargetTypes(value: string | string[] | undefined): string[] {\n  const rawValues = Array.isArray(value) ? value : value ? [value] : [];\n  const values = rawValues.flatMap((item) =>\n    item\n      .split(',')\n      .map((part) => part.trim())\n      .filter(Boolean),\n  );\n  if (!values.length) {\n    throw new CliError('Missing required --target-types value.', {\n      code: 'DATASET_AUTHOR_TARGET_TYPES_REQUIRED',\n      exitCode: 2,\n    });\n  }\n  return [...new Set(values)];\n}\n\nexport const __testInternals = {\n  normalizeTargetTypes,\n};\n"]}

package/dist/src/lib/dataset-bilingual.js

@@ -0,0 +1,545 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { writeJsonArtifact, writeJsonLinesArtifact } from './artifacts.js';
+import { CliError } from './errors.js';
+import { cloneJson, isRecord, materializeDatasetRows, readDatasetRowsInput, trimToken, } from './dataset-local.js';
+import { runDatasetValidate, } from './dataset-validate.js';
+import { runFlowQa } from './flow-qa.js';
+import { runProcessQa } from './process-qa.js';
+const DEFAULT_SOURCE_LANG = 'en';
+const DEFAULT_TARGET_LANG = 'zh';
+const PLACEHOLDER_RE = /\b(?:TODO|TBD|FIXME|REPLACE_ME)\b|待补充|占位/u;
+const CJK_RE = /[\u3400-\u9fff]/u;
+const LATIN_WORD_RE = /[A-Za-z]{3,}/gu;
+const CJK_PLURAL_SUFFIX_RE = /[\u3400-\u9fff]+s\b/u;
+function nowIso(now = new Date()) {
+    return now.toISOString();
+}
+function normalizeType(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || normalized === 'auto') {
+        return 'auto';
+    }
+    if (normalized === 'flow' || normalized === 'flows') {
+        return 'flow';
+    }
+    if (normalized === 'process' || normalized === 'processes') {
+        return 'process';
+    }
+    if (normalized === 'lifecyclemodel' ||
+        normalized === 'lifecyclemodels' ||
+        normalized === 'model' ||
+        normalized === 'models') {
+        return 'lifecyclemodel';
+    }
+    throw new CliError('Expected --type to be auto, flow, process, or lifecyclemodel.', {
+        code: 'DATASET_BILINGUAL_TYPE_INVALID',
+        exitCode: 2,
+        details: value,
+    });
+}
+function normalizeLang(value, fallback) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized || fallback;
+}
+function pointerEscape(segment) {
+    return segment.replace(/~/gu, '~0').replace(/\//gu, '~1');
+}
+function pointerUnescape(segment) {
+    return segment.replace(/~1/gu, '/').replace(/~0/gu, '~');
+}
+function pointerFromSegments(segments) {
+    return `/${segments.map(pointerEscape).join('/')}`;
+}
+function segmentsFromPointer(pointer) {
+    if (!pointer.startsWith('/')) {
+        throw new CliError(`Expected JSON pointer field_path, got: ${pointer}`, {
+            code: 'DATASET_BILINGUAL_FIELD_PATH_INVALID',
+            exitCode: 2,
+        });
+    }
+    return pointer.slice(1).split('/').map(pointerUnescape);
+}
+function textPreview(value) {
+    return value.length > 180 ? `${value.slice(0, 177)}...` : value;
+}
+function langOf(value) {
+    return trimToken(isRecord(value) ? value['@xml:lang'] : null)?.toLowerCase() ?? null;
+}
+function textOf(value) {
+    return trimToken(isRecord(value) ? value['#text'] : null);
+}
+function isLangRecord(value) {
+    return isRecord(value) && (typeof value['@xml:lang'] === 'string' || '#text' in value);
+}
+function isLangRecordArray(value) {
+    return Array.isArray(value) && value.some((item) => isLangRecord(item));
+}
+function hashUnit(parts) {
+    const hash = createHash('sha256');
+    for (const part of parts) {
+        hash.update(String(part ?? ''));
+        hash.update('\n');
+    }
+    return hash.digest('hex').slice(0, 24);
+}
+function filterRowsByType(rows, requestedType) {
+    if (requestedType === 'auto') {
+        return rows;
+    }
+    return rows.filter((row) => row.kind === requestedType);
+}
+function rootFieldFromPath(pathSegments) {
+    return pathSegments.find((segment) => !/^\d+$/u.test(segment)) ?? null;
+}
+function siblingKeys(parent) {
+    if (!isRecord(parent)) {
+        return [];
+    }
+    return Object.keys(parent).sort().slice(0, 20);
+}
+function collectTranslationUnitsFromNode(node, pathSegments, parent, visit, sourceLang, targetLang, units) {
+    if (isLangRecordArray(node)) {
+        const source = node.find((item) => langOf(item) === sourceLang);
+        const target = node.find((item) => langOf(item) === targetLang);
+        const sourceText = textOf(source);
+        if (sourceText) {
+            const fieldPath = pointerFromSegments(pathSegments);
+            units.push({
+                schema_version: 1,
+                unit_id: hashUnit([
+                    visit.rowIndex,
+                    visit.id,
+                    visit.version,
+                    fieldPath,
+                    sourceLang,
+                    targetLang,
+                    sourceText,
+                ]),
+                row_index: visit.rowIndex,
+                dataset_type: visit.kind,
+                dataset_id: visit.id,
+                dataset_version: visit.version,
+                field_path: fieldPath,
+                source_lang: sourceLang,
+                target_lang: targetLang,
+                source_text: sourceText,
+                current_target_text: textOf(target),
+                context: {
+                    root_field: rootFieldFromPath(pathSegments),
+                    sibling_keys: siblingKeys(parent),
+                },
+            });
+        }
+        return;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => collectTranslationUnitsFromNode(item, [...pathSegments, String(index)], node, visit, sourceLang, targetLang, units));
+        return;
+    }
+    if (isRecord(node)) {
+        for (const [key, value] of Object.entries(node)) {
+            collectTranslationUnitsFromNode(value, [...pathSegments, key], node, visit, sourceLang, targetLang, units);
+        }
+    }
+}
+function collectTranslationUnits(rows, sourceLang, targetLang) {
+    const units = [];
+    for (const row of rows) {
+        collectTranslationUnitsFromNode(row.row, [], null, {
+            rowIndex: row.index,
+            row: row.row,
+            kind: row.kind,
+            id: row.id,
+            version: row.version,
+        }, sourceLang, targetLang, units);
+    }
+    return units;
+}
+function outFiles(outDir) {
+    if (!outDir) {
+        return {
+            translation_units: null,
+            report: null,
+        };
+    }
+    const resolved = path.resolve(outDir);
+    return {
+        translation_units: path.join(resolved, 'outputs', 'trans-units.jsonl'),
+        report: path.join(resolved, 'outputs', 'extract-report.json'),
+    };
+}
+function readTranslationInputs(inputPath, rawInput) {
+    return readDatasetRowsInput(inputPath, rawInput).map((row) => {
+        const translatedText = trimToken(row.translated_text) ??
+            trimToken(row.translatedText) ??
+            trimToken(row.translation) ??
+            trimToken(row.target_text) ??
+            trimToken(row.targetText);
+        return {
+            unit_id: trimToken(row.unit_id) ?? trimToken(row.unitId),
+            row_index: typeof row.row_index === 'number'
+                ? row.row_index
+                : typeof row.rowIndex === 'number'
+                    ? row.rowIndex
+                    : null,
+            field_path: trimToken(row.field_path) ?? trimToken(row.fieldPath),
+            source_lang: trimToken(row.source_lang) ?? trimToken(row.sourceLang),
+            target_lang: trimToken(row.target_lang) ?? trimToken(row.targetLang),
+            source_text: trimToken(row.source_text) ?? trimToken(row.sourceText),
+            translated_text: translatedText,
+            basis: trimToken(row.basis) ?? trimToken(row.rationale),
+            review_status: trimToken(row.review_status) ?? trimToken(row.reviewStatus),
+            reviewer: trimToken(row.reviewer),
+        };
+    });
+}
+function resolvePointer(root, pointer) {
+    let current = root;
+    for (const segment of segmentsFromPointer(pointer)) {
+        if (Array.isArray(current)) {
+            current = current[Number(segment)];
+        }
+        else if (isRecord(current)) {
+            current = current[segment];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+function cloneSourceLangRecord(container, sourceLang) {
+    const source = container.find((item) => langOf(item) === sourceLang);
+    const cloned = isRecord(source) ? cloneJson(source) : {};
+    cloned['@xml:lang'] = '';
+    cloned['#text'] = '';
+    return cloned;
+}
+function applyTranslationToRows(options) {
+    const translation = options.translation;
+    if (translation.row_index === null || translation.row_index < 0) {
+        return { applied: false, blocker: 'Translation is missing row_index.' };
+    }
+    if (!translation.field_path) {
+        return { applied: false, blocker: 'Translation is missing field_path.' };
+    }
+    if (!translation.translated_text) {
+        return { applied: false, blocker: 'Translation is missing translated_text.' };
+    }
+    const row = options.rows[translation.row_index];
+    if (!row) {
+        return { applied: false, blocker: `No input row exists at index ${translation.row_index}.` };
+    }
+    const container = resolvePointer(row, translation.field_path);
+    if (!Array.isArray(container)) {
+        return { applied: false, blocker: `field_path does not point to a language array.` };
+    }
+    let target = container.find((item) => isRecord(item) && langOf(item) === options.targetLang);
+    if (!target) {
+        target = cloneSourceLangRecord(container, translation.source_lang ?? 'en');
+        container.push(target);
+    }
+    target['@xml:lang'] = options.targetLang;
+    target['#text'] = translation.translated_text;
+    const materializedRows = materializeDatasetRows('memory', { rows: [row] });
+    const materialized = materializedRows[0];
+    return {
+        applied: true,
+        evidence: {
+            unit_id: translation.unit_id ??
+                hashUnit([
+                    translation.row_index,
+                    translation.field_path,
+                    translation.source_lang,
+                    options.targetLang,
+                    translation.source_text,
+                ]),
+            row_index: translation.row_index,
+            dataset_type: materialized?.kind ?? null,
+            dataset_id: materialized?.id ?? null,
+            dataset_version: materialized?.version ?? null,
+            field_path: translation.field_path,
+            source_lang: translation.source_lang ?? 'en',
+            target_lang: options.targetLang,
+            source_text: translation.source_text ?? '',
+            translated_text: translation.translated_text,
+            basis: translation.basis,
+            review_status: translation.review_status,
+            reviewer: translation.reviewer,
+        },
+    };
+}
+function writeRowsJsonl(filePath, rows) {
+    return writeJsonLinesArtifact(filePath, rows);
+}
+function scanText(node, pathSegments, visit) {
+    const findings = [];
+    if (isLangRecord(node)) {
+        const lang = langOf(node);
+        const text = textOf(node);
+        if (!text) {
+            return findings;
+        }
+        const fieldPath = pointerFromSegments(pathSegments);
+        const base = {
+            row_index: visit.rowIndex,
+            dataset_type: visit.kind,
+            dataset_id: visit.id,
+            dataset_version: visit.version,
+            field_path: fieldPath,
+            lang,
+            text_preview: textPreview(text),
+        };
+        if (PLACEHOLDER_RE.test(text)) {
+            findings.push({
+                ...base,
+                code: 'placeholder_text',
+                severity: 'blocker',
+                message: 'Text contains placeholder markers.',
+            });
+        }
+        if (lang === 'en' && CJK_RE.test(text)) {
+            findings.push({
+                ...base,
+                code: 'english_contains_cjk',
+                severity: 'blocker',
+                message: 'English text contains CJK characters.',
+            });
+        }
+        if (lang === 'zh' && CJK_PLURAL_SUFFIX_RE.test(text)) {
+            findings.push({
+                ...base,
+                code: 'mechanical_plural_suffix',
+                severity: 'blocker',
+                message: 'Chinese text contains mechanical mixed-language plural suffixes.',
+            });
+        }
+        if (lang === 'zh') {
+            const latinWords = text.match(LATIN_WORD_RE) ?? [];
+            if (latinWords.length >= 8) {
+                findings.push({
+                    ...base,
+                    code: 'zh_latin_word_density',
+                    severity: 'warning',
+                    message: 'Chinese text contains many Latin words; review for machine-translation residue.',
+                });
+            }
+        }
+        return findings;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => {
+            findings.push(...scanText(item, [...pathSegments, String(index)], visit));
+        });
+        return findings;
+    }
+    if (isRecord(node)) {
+        for (const [key, value] of Object.entries(node)) {
+            findings.push(...scanText(value, [...pathSegments, key], visit));
+        }
+    }
+    return findings;
+}
+function scanRows(rows) {
+    return rows.flatMap((row) => scanText(row.row, [], {
+        rowIndex: row.index,
+        row: row.row,
+        kind: row.kind,
+        id: row.id,
+        version: row.version,
+    }));
+}
+function validateFiles(outDir) {
+    if (!outDir) {
+        return {
+            report: null,
+            findings: null,
+        };
+    }
+    const resolved = path.resolve(outDir);
+    return {
+        report: path.join(resolved, 'outputs', 'bilingual-validate-report.json'),
+        findings: path.join(resolved, 'outputs', 'bilingual-findings.jsonl'),
+    };
+}
+export async function runDatasetBilingualExtract(options) {
+    const requestedType = normalizeType(options.type);
+    const sourceLang = normalizeLang(options.sourceLang, DEFAULT_SOURCE_LANG);
+    const targetLang = normalizeLang(options.targetLang, DEFAULT_TARGET_LANG);
+    const rows = filterRowsByType(materializeDatasetRows(options.inputPath, options.rawInput), requestedType);
+    const units = collectTranslationUnits(rows, sourceLang, targetLang);
+    const files = outFiles(options.outDir);
+    const report = {
+        schema_version: 1,
+        generated_at_utc: nowIso(options.now),
+        input_path: options.inputPath,
+        requested_type: requestedType,
+        source_lang: sourceLang,
+        target_lang: targetLang,
+        unit_count: units.length,
+        row_count: rows.length,
+        files,
+    };
+    if (files.translation_units) {
+        writeJsonLinesArtifact(files.translation_units, units);
+    }
+    if (files.report) {
+        writeJsonArtifact(files.report, report);
+    }
+    return report;
+}
+export async function runDatasetBilingualApply(options) {
+    const targetLang = normalizeLang(options.targetLang, DEFAULT_TARGET_LANG);
+    if (!options.outPath) {
+        throw new CliError('Missing required --out value.', {
+            code: 'DATASET_BILINGUAL_OUT_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    if (!options.translationsPath) {
+        throw new CliError('Missing required --translations value.', {
+            code: 'DATASET_BILINGUAL_TRANSLATIONS_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    const rows = readDatasetRowsInput(options.inputPath, options.rawInput).map((row) => cloneJson(row));
+    const translations = readTranslationInputs(options.translationsPath, options.rawTranslations);
+    const blockers = [];
+    const evidence = [];
+    let appliedCount = 0;
+    let skippedCount = 0;
+    for (const translation of translations) {
+        const result = applyTranslationToRows({ rows, translation, targetLang });
+        if (result.applied) {
+            appliedCount += 1;
+            evidence.push(result.evidence);
+        }
+        else {
+            skippedCount += 1;
+            blockers.push({
+                code: 'translation_not_applied',
+                message: result.blocker,
+                unit_id: translation.unit_id ?? undefined,
+            });
+        }
+    }
+    const resolvedOut = path.resolve(options.outPath);
+    const resolvedOutDir = options.outDir ? path.resolve(options.outDir) : path.dirname(resolvedOut);
+    const evidenceFile = path.join(resolvedOutDir, 'outputs', 'translation-evidence.json');
+    const reportFile = path.join(resolvedOutDir, 'outputs', 'bilingual-apply-report.json');
+    writeRowsJsonl(resolvedOut, rows);
+    writeJsonArtifact(evidenceFile, {
+        schema_version: 1,
+        generated_at_utc: nowIso(options.now),
+        entries: evidence,
+    });
+    const report = {
+        schema_version: 1,
+        generated_at_utc: nowIso(options.now),
+        input_path: options.inputPath,
+        translations_path: options.translationsPath,
+        out_path: resolvedOut,
+        target_lang: targetLang,
+        status: blockers.length > 0 ? 'blocked' : 'completed',
+        row_count: rows.length,
+        translation_count: translations.length,
+        applied_count: appliedCount,
+        skipped_count: skippedCount,
+        blockers,
+        files: {
+            translated_rows: resolvedOut,
+            translation_evidence: evidenceFile,
+            report: reportFile,
+        },
+    };
+    writeJsonArtifact(reportFile, report);
+    return report;
+}
+export async function runDatasetBilingualValidate(options) {
+    const requestedType = normalizeType(options.type);
+    const rows = filterRowsByType(materializeDatasetRows(options.inputPath, options.rawInput), requestedType);
+    const findings = scanRows(rows);
+    const files = validateFiles(options.outDir);
+    const datasetValidateImpl = options.datasetValidateImpl ?? runDatasetValidate;
+    const schemaGateOutDir = options.outDir
+        ? path.join(path.resolve(options.outDir), 'schema')
+        : null;
+    const schemaReport = await datasetValidateImpl({
+        inputPath: options.inputPath,
+        type: requestedType,
+        outDir: schemaGateOutDir,
+        rawInput: { rows: rows.map((row) => row.row) },
+        now: options.now,
+        schemas: options.schemas,
+    });
+    let processReport = null;
+    let flowReport = null;
+    if (options.outDir && (requestedType === 'process' || requestedType === 'auto')) {
+        const processRows = rows.filter((row) => row.kind === 'process').map((row) => row.row);
+        if (processRows.length > 0) {
+            const processRowsFile = path.join(path.resolve(options.outDir), 'qa-input-processes.jsonl');
+            writeJsonLinesArtifact(processRowsFile, processRows);
+            processReport = await (options.processQaImpl ?? runProcessQa)({
+                rowsFile: processRowsFile,
+                outDir: path.join(path.resolve(options.outDir), 'qa', 'process'),
+                now: () => options.now ?? new Date(),
+            });
+        }
+    }
+    if (options.outDir && (requestedType === 'flow' || requestedType === 'auto')) {
+        const flowRows = rows.filter((row) => row.kind === 'flow').map((row) => row.row);
+        if (flowRows.length > 0) {
+            const flowRowsFile = path.join(path.resolve(options.outDir), 'qa-input-flows.jsonl');
+            writeJsonLinesArtifact(flowRowsFile, flowRows);
+            flowReport = await (options.flowQaImpl ?? runFlowQa)({
+                rowsFile: flowRowsFile,
+                outDir: path.join(path.resolve(options.outDir), 'qa', 'flow'),
+                now: () => options.now ?? new Date(),
+            });
+        }
+    }
+    const blockerCount = findings.filter((finding) => finding.severity === 'blocker').length;
+    const warningCount = findings.filter((finding) => finding.severity === 'warning').length;
+    const report = {
+        schema_version: 1,
+        generated_at_utc: nowIso(options.now),
+        input_path: options.inputPath,
+        requested_type: requestedType,
+        status: blockerCount > 0 || schemaReport.counts.invalid > 0 ? 'blocked' : 'completed',
+        row_count: rows.length,
+        scan: {
+            finding_count: findings.length,
+            blocker_count: blockerCount,
+            warning_count: warningCount,
+            findings,
+        },
+        schema_gate: {
+            status: schemaReport.status,
+            valid: schemaReport.counts.valid,
+            invalid: schemaReport.counts.invalid,
+            report_file: schemaReport.files.report,
+        },
+        qa_gate: {
+            status: processReport || flowReport ? 'completed' : 'not_run',
+            process_report_file: processReport?.files.report ?? null,
+            flow_report_file: flowReport?.files.report ?? null,
+        },
+        files,
+    };
+    if (files.findings) {
+        writeJsonLinesArtifact(files.findings, findings);
+    }
+    if (files.report) {
+        writeJsonArtifact(files.report, report);
+    }
+    return report;
+}
+export const __testInternals = {
+    collectTranslationUnits,
+    normalizeType,
+    pointerFromSegments,
+    segmentsFromPointer,
+    scanRows,
+};
+//# sourceMappingURL=dataset-bilingual.js.map