@tiangong-lca/cli 0.0.11 → 0.0.13

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

@@ -0,0 +1,797 @@
+import crypto from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { writeJsonArtifact, writeJsonLinesArtifact } from './artifacts.js';
+import { cloneJson, isRecord, materializeDatasetRows, trimToken, } from './dataset-local.js';
+import { CliError } from './errors.js';
+import { readJsonInput } from './io.js';
+const decisionOnlyActionKinds = new Set([
+    'identity_decision_authoring',
+    'classification_decision_authoring',
+    'location_decision_authoring',
+]);
+function nowIso(now) {
+    return (now ?? new Date()).toISOString();
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function parseRowIndex(value) {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    if (typeof value === 'string' && /^\d+$/u.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    return null;
+}
+function nonEmptyString(value) {
+    return trimToken(value);
+}
+function sha256Text(value) {
+    return crypto.createHash('sha256').update(value).digest('hex');
+}
+function caughtErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function normalizeClosure(value) {
+    if (typeof value === 'string') {
+        const code = value.trim();
+        return code ? { code, path: null } : null;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    const code = nonEmptyString(value.code) ??
+        nonEmptyString(value.action_item_code) ??
+        nonEmptyString(value.actionItemCode) ??
+        nonEmptyString(value.rule_id) ??
+        nonEmptyString(value.ruleId);
+    if (!code) {
+        return null;
+    }
+    return {
+        code,
+        path: nonEmptyString(value.path) ??
+            nonEmptyString(value.json_path) ??
+            nonEmptyString(value.jsonPath) ??
+            null,
+    };
+}
+function actionItemClosureKey(value) {
+    return `${value.code}\u0000${value.path ?? ''}`;
+}
+function normalizeClosureList(value) {
+    const values = Array.isArray(value)
+        ? value
+        : value === undefined || value === null
+            ? []
+            : [value];
+    const closures = values
+        .map(normalizeClosure)
+        .filter((closure) => closure !== null);
+    return [...new Map(closures.map((closure) => [actionItemClosureKey(closure), closure])).values()];
+}
+function operationClosures(operation) {
+    return normalizeClosureList(operation.closes ??
+        operation.closes_action_items ??
+        operation.closesActionItems ??
+        operation.action_items ??
+        operation.actionItems);
+}
+function actionItemFromPackage(value) {
+    if (!isRecord(value) || value.ai_required === false) {
+        return null;
+    }
+    const actionKind = nonEmptyString(value.action_kind) ?? nonEmptyString(value.actionKind);
+    if (actionKind && decisionOnlyActionKinds.has(actionKind)) {
+        return null;
+    }
+    const code = nonEmptyString(value.code) ?? nonEmptyString(value.rule_id) ?? nonEmptyString(value.ruleId);
+    if (!code) {
+        return null;
+    }
+    return {
+        code,
+        path: nonEmptyString(value.path) ?? null,
+    };
+}
+function closureMatchesActionItem(closure, actionItem) {
+    return (closure.code === actionItem.code &&
+        (!closure.path || !actionItem.path || closure.path === actionItem.path));
+}
+function normalizeOperationArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    if (!value.every(looksLikeOperation)) {
+        return null;
+    }
+    return value;
+}
+function looksLikeOperation(value) {
+    return isRecord(value) && typeof value.op === 'string' && typeof value.path === 'string';
+}
+function normalizePatchSet(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const operations = normalizeOperationArray(value.operations) ?? normalizeOperationArray(value.patches);
+    if (!operations) {
+        return null;
+    }
+    return {
+        rowIndex: parseRowIndex(value.row_index ?? value.rowIndex),
+        datasetId: nonEmptyString(value.dataset_id) ??
+            nonEmptyString(value.id) ??
+            nonEmptyString(value.uuid) ??
+            nonEmptyString(value.entity_id),
+        datasetVersion: nonEmptyString(value.dataset_version) ?? nonEmptyString(value.version),
+        authoringPackage: nonEmptyString(value.authoring_package) ?? nonEmptyString(value.authoringPackage),
+        operations,
+    };
+}
+function patchPayloadCompletionStatus(rawPatch) {
+    if (typeof rawPatch !== 'object' || rawPatch === null) {
+        return null;
+    }
+    const value = rawPatch;
+    return (nonEmptyString(value.patch_status) ??
+        nonEmptyString(value.patchStatus) ??
+        nonEmptyString(value.status));
+}
+function normalizePatchPayload(rawPatch) {
+    const blockers = [];
+    const patches = [];
+    const addPatchSet = (value, patchIndex) => {
+        const patch = normalizePatchSet(value);
+        if (patch) {
+            patches.push(patch);
+            return;
+        }
+        blockers.push({
+            code: 'patch_set_invalid',
+            message: 'Patch set must be an object with row_index or dataset_id and operations[].',
+            patch_index: patchIndex,
+        });
+    };
+    const patchStatus = patchPayloadCompletionStatus(rawPatch);
+    if (patchStatus !== 'completed') {
+        blockers.push({
+            code: 'ai_patch_status_not_completed',
+            message: 'Patch payload must declare patch_status=completed before deterministic apply.',
+        });
+        return { patches, blockers };
+    }
+    if (Array.isArray(rawPatch)) {
+        if (rawPatch.every(looksLikeOperation)) {
+            blockers.push({
+                code: 'patch_row_required',
+                message: 'Top-level operation arrays are not supported because they do not identify a row.',
+            });
+            return { patches, blockers };
+        }
+        rawPatch.forEach(addPatchSet);
+        return { patches, blockers };
+    }
+    const patchObject = rawPatch;
+    const directPatch = normalizePatchSet(patchObject);
+    if (directPatch) {
+        patches.push(directPatch);
+        return { patches, blockers };
+    }
+    const candidateList = (Array.isArray(patchObject.patch_sets) ? patchObject.patch_sets : null) ??
+        (Array.isArray(patchObject.patches) ? patchObject.patches : null) ??
+        (Array.isArray(patchObject.suggestions) ? patchObject.suggestions : null) ??
+        (Array.isArray(patchObject.items) ? patchObject.items : null);
+    if (candidateList) {
+        if (candidateList.every(looksLikeOperation)) {
+            blockers.push({
+                code: 'patch_row_required',
+                message: 'Top-level operation arrays are not supported because they do not identify a row.',
+            });
+            return { patches, blockers };
+        }
+        candidateList.forEach(addPatchSet);
+        return { patches, blockers };
+    }
+    blockers.push({
+        code: 'patch_payload_invalid',
+        message: 'Patch payload must contain operations[], patches[], patch_sets[], suggestions[], or items[].',
+    });
+    return { patches, blockers };
+}
+function decodePointerToken(token) {
+    if (/(^|[^~])~([^01]|$)/u.test(token)) {
+        throw new Error(`Invalid JSON Pointer escape in token: ${token}`);
+    }
+    return token.replace(/~1/gu, '/').replace(/~0/gu, '~');
+}
+function parsePointer(pointer) {
+    if (typeof pointer !== 'string' || !pointer.startsWith('/')) {
+        throw new Error('Patch path must be a JSON Pointer starting with /.');
+    }
+    return pointer
+        .slice(1)
+        .split('/')
+        .map((token) => decodePointerToken(token));
+}
+function parseArrayIndex(token, length, allowAppend) {
+    if (allowAppend && token === '-') {
+        return length;
+    }
+    if (!/^(0|[1-9]\d*)$/u.test(token)) {
+        throw new Error(`Expected array index, got ${token}.`);
+    }
+    const index = Number.parseInt(token, 10);
+    if (index < 0 || index > length || (!allowAppend && index === length)) {
+        throw new Error(`Array index out of bounds: ${token}.`);
+    }
+    return index;
+}
+function resolvePatchTarget(root, pointer, allowAdd) {
+    const tokens = parsePointer(pointer);
+    let current = root;
+    for (const token of tokens.slice(0, -1)) {
+        if (Array.isArray(current)) {
+            current = current[parseArrayIndex(token, current.length, false)];
+            continue;
+        }
+        if (isRecord(current)) {
+            if (!hasOwn(current, token)) {
+                throw new Error(`Patch parent path does not exist at ${token}.`);
+            }
+            current = current[token];
+            continue;
+        }
+        throw new Error(`Patch parent is not an object or array at ${token}.`);
+    }
+    const keyToken = tokens[tokens.length - 1];
+    if (Array.isArray(current)) {
+        return {
+            container: current,
+            key: parseArrayIndex(keyToken, current.length, allowAdd),
+        };
+    }
+    if (isRecord(current)) {
+        return { container: current, key: keyToken };
+    }
+    throw new Error('Patch parent is not an object or array.');
+}
+function targetExists(target) {
+    if (Array.isArray(target.container)) {
+        return (typeof target.key === 'number' && target.key >= 0 && target.key < target.container.length);
+    }
+    return typeof target.key === 'string' && hasOwn(target.container, target.key);
+}
+function getTargetValue(target) {
+    if (!targetExists(target)) {
+        throw new Error('Patch target path does not exist.');
+    }
+    return target.container[target.key];
+}
+function setTargetValue(target, value, insert) {
+    if (Array.isArray(target.container)) {
+        const index = target.key;
+        if (insert) {
+            target.container.splice(index, 0, value);
+            return;
+        }
+        target.container[index] = value;
+        return;
+    }
+    target.container[target.key] = value;
+}
+function removeTargetValue(target) {
+    if (!targetExists(target)) {
+        throw new Error('Patch target path does not exist.');
+    }
+    if (Array.isArray(target.container)) {
+        target.container.splice(target.key, 1);
+        return;
+    }
+    delete target.container[target.key];
+}
+function evidenceIsPresent(evidence) {
+    if (typeof evidence === 'string') {
+        return evidence.trim().length > 0;
+    }
+    if (Array.isArray(evidence)) {
+        return evidence.length > 0;
+    }
+    if (isRecord(evidence)) {
+        return Object.keys(evidence).length > 0;
+    }
+    return false;
+}
+function operationBasis(operation) {
+    return nonEmptyString(operation.basis);
+}
+function requiresEvidence(operation) {
+    return operation.op !== 'test';
+}
+function validateOperationShape(operation, patchIndex, operationIndex, rowIndex, datasetId, datasetVersion) {
+    if (!['add', 'remove', 'replace', 'test'].includes(operation.op)) {
+        return {
+            code: 'patch_operation_unsupported',
+            message: `Unsupported patch operation: ${operation.op}`,
+            row_index: rowIndex,
+            dataset_id: datasetId,
+            dataset_version: datasetVersion,
+            patch_index: patchIndex,
+            operation_index: operationIndex,
+            op: operation.op,
+            path: operation.path,
+        };
+    }
+    if (typeof operation.path !== 'string' || !operation.path.startsWith('/')) {
+        return {
+            code: 'patch_path_invalid',
+            message: 'Patch operation path must be a JSON Pointer starting with /.',
+            row_index: rowIndex,
+            dataset_id: datasetId,
+            dataset_version: datasetVersion,
+            patch_index: patchIndex,
+            operation_index: operationIndex,
+            op: operation.op,
+            path: operation.path,
+        };
+    }
+    if (['add', 'replace', 'test'].includes(operation.op) && !hasOwn(operation, 'value')) {
+        return {
+            code: 'patch_value_required',
+            message: `${operation.op} operation requires value.`,
+            row_index: rowIndex,
+            dataset_id: datasetId,
+            dataset_version: datasetVersion,
+            patch_index: patchIndex,
+            operation_index: operationIndex,
+            op: operation.op,
+            path: operation.path,
+        };
+    }
+    if (requiresEvidence(operation) &&
+        !operationBasis(operation) &&
+        !evidenceIsPresent(operation.evidence)) {
+        return {
+            code: 'patch_evidence_required',
+            message: 'Non-test patch operations require basis or evidence.',
+            row_index: rowIndex,
+            dataset_id: datasetId,
+            dataset_version: datasetVersion,
+            patch_index: patchIndex,
+            operation_index: operationIndex,
+            op: operation.op,
+            path: operation.path,
+        };
+    }
+    return null;
+}
+function applyOperation(root, operation) {
+    const op = operation.op;
+    const target = resolvePatchTarget(root, operation.path, op === 'add');
+    if (op === 'test') {
+        const actual = getTargetValue(target);
+        if (!isDeepStrictEqual(actual, operation.value)) {
+            throw new Error('Patch test failed.');
+        }
+        return;
+    }
+    if (op === 'remove') {
+        removeTargetValue(target);
+        return;
+    }
+    if (op === 'replace') {
+        if (!targetExists(target)) {
+            throw new Error('Patch target path does not exist.');
+        }
+        setTargetValue(target, operation.value, false);
+        return;
+    }
+    setTargetValue(target, operation.value, Array.isArray(target.container));
+}
+function findTargetRow(patch, rows, patchIndex) {
+    if (patch.rowIndex !== null) {
+        if (patch.rowIndex >= rows.length) {
+            return {
+                rowIndex: null,
+                blocker: {
+                    code: 'patch_row_index_invalid',
+                    message: `Patch row_index ${patch.rowIndex} is outside input row count ${rows.length}.`,
+                    row_index: patch.rowIndex,
+                    dataset_id: patch.datasetId,
+                    dataset_version: patch.datasetVersion,
+                    patch_index: patchIndex,
+                },
+            };
+        }
+        const row = rows[patch.rowIndex];
+        if (patch.datasetId && row?.id !== patch.datasetId) {
+            return {
+                rowIndex: null,
+                blocker: {
+                    code: 'patch_dataset_id_mismatch',
+                    message: `Patch dataset_id ${patch.datasetId} does not match row_index ${patch.rowIndex}.`,
+                    row_index: patch.rowIndex,
+                    dataset_id: patch.datasetId,
+                    dataset_version: patch.datasetVersion,
+                    patch_index: patchIndex,
+                },
+            };
+        }
+        if (patch.datasetVersion && row?.version !== patch.datasetVersion) {
+            return {
+                rowIndex: null,
+                blocker: {
+                    code: 'patch_dataset_version_mismatch',
+                    message: `Patch dataset_version ${patch.datasetVersion} does not match row_index ${patch.rowIndex}.`,
+                    row_index: patch.rowIndex,
+                    dataset_id: patch.datasetId,
+                    dataset_version: patch.datasetVersion,
+                    patch_index: patchIndex,
+                },
+            };
+        }
+        return { rowIndex: patch.rowIndex, blocker: null };
+    }
+    if (!patch.datasetId) {
+        return {
+            rowIndex: null,
+            blocker: {
+                code: 'patch_row_required',
+                message: 'Patch set must identify a target row by row_index or dataset_id.',
+                dataset_id: patch.datasetId,
+                dataset_version: patch.datasetVersion,
+                patch_index: patchIndex,
+            },
+        };
+    }
+    const matches = rows.filter((row) => row.id === patch.datasetId && (!patch.datasetVersion || row.version === patch.datasetVersion));
+    if (matches.length === 0) {
+        return {
+            rowIndex: null,
+            blocker: {
+                code: 'patch_dataset_not_found',
+                message: `No input row matched dataset_id ${patch.datasetId}.`,
+                dataset_id: patch.datasetId,
+                dataset_version: patch.datasetVersion,
+                patch_index: patchIndex,
+            },
+        };
+    }
+    if (matches.length > 1) {
+        return {
+            rowIndex: null,
+            blocker: {
+                code: 'patch_dataset_ambiguous',
+                message: `Multiple input rows matched dataset_id ${patch.datasetId}; use row_index or dataset_version.`,
+                dataset_id: patch.datasetId,
+                dataset_version: patch.datasetVersion,
+                patch_index: patchIndex,
+            },
+        };
+    }
+    return { rowIndex: matches[0].index, blocker: null };
+}
+function resolveAuthoringPackagePath(authoringPackage, authoringPackageDir) {
+    if (!authoringPackage) {
+        return null;
+    }
+    const directPath = path.resolve(authoringPackage);
+    if (existsSync(directPath)) {
+        return directPath;
+    }
+    if (authoringPackageDir) {
+        const fromDir = path.resolve(authoringPackageDir, authoringPackage);
+        if (existsSync(fromDir)) {
+            return fromDir;
+        }
+        const byBasename = path.resolve(authoringPackageDir, path.basename(authoringPackage));
+        if (existsSync(byBasename)) {
+            return byBasename;
+        }
+    }
+    return directPath;
+}
+function readAuthoringPackageContext(options) {
+    const blockers = [];
+    const packagePath = resolveAuthoringPackagePath(options.patch.authoringPackage, options.authoringPackageDir);
+    if (!packagePath) {
+        if (options.requireAuthoringPackage) {
+            blockers.push({
+                code: 'authoring_package_required',
+                message: 'Strict patch apply requires each patch set to identify an authoring_package.',
+                row_index: options.rowIndex,
+                dataset_id: options.rowId,
+                dataset_version: options.rowVersion,
+                patch_index: options.patchIndex,
+            });
+        }
+        return { context: null, blockers };
+    }
+    if (!existsSync(packagePath)) {
+        blockers.push({
+            code: 'authoring_package_not_found',
+            message: `Authoring package was not found: ${packagePath}`,
+            row_index: options.rowIndex,
+            dataset_id: options.rowId,
+            dataset_version: options.rowVersion,
+            patch_index: options.patchIndex,
+        });
+        return { context: null, blockers };
+    }
+    let rawText;
+    let payload;
+    try {
+        rawText = readFileSync(packagePath, 'utf8');
+        payload = JSON.parse(rawText);
+    }
+    catch (error) {
+        blockers.push({
+            code: 'authoring_package_invalid',
+            message: caughtErrorMessage(error),
+            row_index: options.rowIndex,
+            dataset_id: options.rowId,
+            dataset_version: options.rowVersion,
+            patch_index: options.patchIndex,
+        });
+        return { context: null, blockers };
+    }
+    if (!isRecord(payload)) {
+        blockers.push({
+            code: 'authoring_package_invalid',
+            message: 'Authoring package must be a JSON object.',
+            row_index: options.rowIndex,
+            dataset_id: options.rowId,
+            dataset_version: options.rowVersion,
+            patch_index: options.patchIndex,
+        });
+        return { context: null, blockers };
+    }
+    const packageEntityId = nonEmptyString(payload.entity_id) ?? nonEmptyString(payload.process_id);
+    const packageVersion = nonEmptyString(payload.version);
+    const rowId = nonEmptyString(options.rowId) ?? options.patch.datasetId;
+    const rowVersion = nonEmptyString(options.rowVersion) ?? options.patch.datasetVersion;
+    if (packageEntityId && rowId && packageEntityId !== rowId) {
+        blockers.push({
+            code: 'authoring_package_entity_mismatch',
+            message: `Authoring package entity_id ${packageEntityId} does not match target row ${rowId}.`,
+            row_index: options.rowIndex,
+            dataset_id: rowId,
+            dataset_version: rowVersion,
+            patch_index: options.patchIndex,
+        });
+    }
+    if (packageVersion && rowVersion && packageVersion !== rowVersion) {
+        blockers.push({
+            code: 'authoring_package_version_mismatch',
+            message: `Authoring package version ${packageVersion} does not match target row ${rowVersion}.`,
+            row_index: options.rowIndex,
+            dataset_id: rowId,
+            dataset_version: rowVersion,
+            patch_index: options.patchIndex,
+        });
+    }
+    const actionItems = normalizeClosureList((Array.isArray(payload.action_items) ? payload.action_items : [])
+        .map(actionItemFromPackage)
+        .filter((item) => item !== null));
+    return {
+        context: {
+            path: packagePath,
+            sha256: sha256Text(rawText),
+            payload,
+            actionItems,
+        },
+        blockers,
+    };
+}
+export async function runDatasetPatchApply(options) {
+    if (!options.inputPath) {
+        throw new CliError('Missing required --input value.', {
+            code: 'DATASET_PATCH_INPUT_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    if (!options.patchPath) {
+        throw new CliError('Missing required --patch value.', {
+            code: 'DATASET_PATCH_PATCH_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    if (!options.outPath) {
+        throw new CliError('Missing required --out value.', {
+            code: 'DATASET_PATCH_OUT_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    const rows = materializeDatasetRows(options.inputPath, options.rawInput);
+    const originalRows = rows.map((row) => cloneJson(row.row));
+    const candidateRows = rows.map((row) => cloneJson(row.row));
+    const rawPatch = options.rawPatch ?? readJsonInput(path.resolve(options.patchPath));
+    const normalized = normalizePatchPayload(rawPatch);
+    const blockers = [...normalized.blockers];
+    const evidenceEntries = [];
+    let operationCount = 0;
+    let tentativeAppliedCount = 0;
+    normalized.patches.forEach((patch, patchIndex) => {
+        operationCount += patch.operations.length;
+        const target = findTargetRow(patch, rows, patchIndex);
+        if (target.blocker) {
+            blockers.push(target.blocker);
+            return;
+        }
+        const rowIndex = target.rowIndex;
+        const row = rows[rowIndex];
+        const rowId = row.id ?? patch.datasetId;
+        const rowVersion = row.version ?? patch.datasetVersion;
+        if (patch.operations.length === 0) {
+            blockers.push({
+                code: 'patch_operations_missing',
+                message: 'Patch set operations[] must not be empty.',
+                row_index: rowIndex,
+                dataset_id: rowId,
+                dataset_version: rowVersion,
+                patch_index: patchIndex,
+            });
+            return;
+        }
+        const candidateRow = candidateRows[rowIndex];
+        const shouldValidateAuthoringPackage = Boolean(options.authoringPackageDir) ||
+            options.requireAuthoringPackage === true ||
+            options.requireActionItemClosure === true;
+        const packageResult = shouldValidateAuthoringPackage
+            ? readAuthoringPackageContext({
+                patch,
+                rowIndex,
+                rowId: row.id,
+                rowVersion: row.version,
+                patchIndex,
+                authoringPackageDir: options.authoringPackageDir,
+                requireAuthoringPackage: options.requireAuthoringPackage === true || options.requireActionItemClosure === true,
+            })
+            : { context: null, blockers: [] };
+        blockers.push(...packageResult.blockers);
+        if (packageResult.blockers.length > 0) {
+            return;
+        }
+        const packageContext = packageResult.context;
+        const closedActionItems = [];
+        patch.operations.forEach((operation, operationIndex) => {
+            const shapeBlocker = validateOperationShape(operation, patchIndex, operationIndex, rowIndex, rowId, rowVersion);
+            if (shapeBlocker) {
+                blockers.push(shapeBlocker);
+                return;
+            }
+            const closesActionItems = operationClosures(operation);
+            if (options.requireActionItemClosure === true && packageContext) {
+                for (const closure of closesActionItems) {
+                    if (!packageContext.actionItems.some((item) => closureMatchesActionItem(closure, item))) {
+                        blockers.push({
+                            code: 'authoring_action_item_unknown',
+                            message: `Patch operation closes unknown authoring action item ${closure.code}.`,
+                            row_index: rowIndex,
+                            dataset_id: rowId,
+                            dataset_version: rowVersion,
+                            patch_index: patchIndex,
+                            operation_index: operationIndex,
+                            op: operation.op,
+                            path: operation.path,
+                        });
+                    }
+                }
+            }
+            closedActionItems.push(...closesActionItems);
+            try {
+                applyOperation(candidateRow, operation);
+                tentativeAppliedCount += operation.op === 'test' ? 0 : 1;
+                if (operation.op !== 'test') {
+                    evidenceEntries.push({
+                        row_index: rowIndex,
+                        dataset_id: rowId,
+                        dataset_version: rowVersion,
+                        patch_index: patchIndex,
+                        operation_index: operationIndex,
+                        op: operation.op,
+                        path: operation.path,
+                        basis: operationBasis(operation),
+                        evidence: operation.evidence ?? null,
+                        resolution: operation.resolution ?? null,
+                        authoring_package: patch.authoringPackage,
+                        authoring_package_sha256: packageContext?.sha256 ?? null,
+                        closes_action_items: closesActionItems,
+                    });
+                }
+            }
+            catch (error) {
+                blockers.push({
+                    code: operation.op === 'test' ? 'patch_test_failed' : 'patch_apply_failed',
+                    message: caughtErrorMessage(error),
+                    row_index: rowIndex,
+                    dataset_id: rowId,
+                    dataset_version: rowVersion,
+                    patch_index: patchIndex,
+                    operation_index: operationIndex,
+                    op: operation.op,
+                    path: operation.path,
+                });
+            }
+        });
+        if (options.requireActionItemClosure === true && packageContext) {
+            for (const actionItem of packageContext.actionItems) {
+                if (!closedActionItems.some((closure) => closureMatchesActionItem(closure, actionItem))) {
+                    blockers.push({
+                        code: 'authoring_action_item_unclosed',
+                        message: `Authoring action item ${actionItem.code} was not closed by the AI patch set.`,
+                        row_index: rowIndex,
+                        dataset_id: rowId,
+                        dataset_version: rowVersion,
+                        patch_index: patchIndex,
+                        path: actionItem.path ?? undefined,
+                    });
+                }
+            }
+        }
+    });
+    const resolvedOut = path.resolve(options.outPath);
+    const resolvedOutDir = options.outDir ? path.resolve(options.outDir) : path.dirname(resolvedOut);
+    const evidenceFile = path.join(resolvedOutDir, 'outputs', 'patch-evidence.jsonl');
+    const reportFile = path.join(resolvedOutDir, 'outputs', 'dataset-patch-apply-report.json');
+    const status = blockers.length > 0 ? 'blocked' : 'completed';
+    const outputRows = status === 'completed' ? candidateRows : originalRows;
+    writeJsonLinesArtifact(resolvedOut, outputRows);
+    writeJsonLinesArtifact(evidenceFile, status === 'completed' ? evidenceEntries : []);
+    const report = {
+        schema_version: 1,
+        generated_at_utc: nowIso(options.now),
+        input_path: options.inputPath,
+        patch_path: options.patchPath,
+        out_path: resolvedOut,
+        status,
+        row_count: rows.length,
+        patch_count: normalized.patches.length,
+        operation_count: operationCount,
+        applied_operation_count: status === 'completed' ? tentativeAppliedCount : 0,
+        evidence_count: status === 'completed' ? evidenceEntries.length : 0,
+        closed_action_item_count: status === 'completed'
+            ? evidenceEntries.reduce((total, entry) => total + entry.closes_action_items.length, 0)
+            : 0,
+        blockers,
+        files: {
+            patched_rows: resolvedOut,
+            patch_evidence: evidenceFile,
+            report: reportFile,
+        },
+    };
+    writeJsonArtifact(reportFile, report);
+    return report;
+}
+export const __testInternals = {
+    actionItemFromPackage,
+    applyOperation,
+    closureMatchesActionItem,
+    caughtErrorMessage,
+    evidenceIsPresent,
+    findTargetRow,
+    getTargetValue,
+    looksLikeOperation,
+    normalizeClosure,
+    normalizeClosureList,
+    normalizeOperationArray,
+    normalizePatchPayload,
+    normalizePatchSet,
+    operationBasis,
+    operationClosures,
+    parseArrayIndex,
+    parsePointer,
+    parseRowIndex,
+    patchPayloadCompletionStatus,
+    readAuthoringPackageContext,
+    removeTargetValue,
+    resolveAuthoringPackagePath,
+    resolvePatchTarget,
+    setTargetValue,
+    targetExists,
+    validateOperationShape,
+};
+//# sourceMappingURL=dataset-patch.js.map