@tiangong-lca/cli 0.0.30 → 0.0.32

package/dist/src/lib/dataset-save-draft-run.js

@@ -446,11 +446,17 @@ function schemaForConfig(config) {
 }
 function validatePayload(payload, type, config) {
     const { schema, createEntity } = schemaForConfig(config);
-    const outcome = validateSchemaWithDeepFallback(schema, payload, createEntity);
+    // SDK schema/entity validation may apply defaults by mutating its input. Keep validation
+    // isolated so execution-contract hashing, dispatch, and readback all use the exact input.
+    const validationPayload = structuredClone(payload);
+    const outcome = validateSchemaWithDeepFallback(schema, validationPayload, createEntity);
     const processIssues = type === 'process'
-        ? [...collectProcessRequiredFieldIssues(payload), ...collectProcessPlaceholderIssues(payload)]
+        ? [
+            ...collectProcessRequiredFieldIssues(validationPayload),
+            ...collectProcessPlaceholderIssues(validationPayload),
+        ]
         : [];
-    const importIssues = type === 'process' ? [] : collectImportContentIssues(payload);
+    const importIssues = type === 'process' ? [] : collectImportContentIssues(validationPayload);
     const issues = [
         ...outcome.issues.map(normalizeValidationIssue),
         ...processIssues,
@@ -902,6 +908,42 @@ async function readbackIsDesiredExact(options) {
         return false;
     }
 }
+function normalizeExecutionMaxParallel(value) {
+    const normalized = value ?? 1;
+    if (!Number.isInteger(normalized) || normalized < 1 || normalized > 8) {
+        executionContractError('Execution contract --max-parallel must be an integer from 1 to 8.');
+    }
+    return normalized;
+}
+function executionSerialPrefixLength(contract) {
+    const actionIndexes = new Map(contract.actions.map((action, index) => [action.action_id, index]));
+    let highestDependencyIndex = -1;
+    for (const action of contract.actions) {
+        for (const dependencyActionId of action.dependency_action_ids) {
+            highestDependencyIndex = Math.max(highestDependencyIndex, actionIndexes.get(dependencyActionId));
+        }
+    }
+    return highestDependencyIndex + 1;
+}
+function assertParallelSuffixTargetsAreUnique(contract, serialPrefixLength) {
+    const targets = new Set();
+    for (const action of contract.actions.slice(serialPrefixLength)) {
+        const target = `${action.table}\u0000${action.id}\u0000${action.version}`;
+        if (targets.has(target)) {
+            executionContractError('Execution contract parallel suffix contains a repeated table/id/version target.');
+        }
+        targets.add(target);
+    }
+}
+async function renewExecutionOwnerToken(options) {
+    const accessToken = await options.runtime.getAccessToken();
+    const actor = decodeExecutionActor(accessToken);
+    if (actor.user_id !== options.contract.owner.user_id ||
+        actor.email !== options.contract.owner.email) {
+        executionContractError('Renewed owner session does not match the execution contract.');
+    }
+    options.commandTransport.accessToken = accessToken;
+}
 async function runExecutionContractBatch(options) {
     const contractSha256 = sha256Json(options.contract);
     const ledgerRoot = executionLedgerRoot(options.env, options.contract);
@@ -913,11 +955,20 @@ async function runExecutionContractBatch(options) {
         executionContractError('Owner session or project does not match the execution contract.');
     }
     options.files.execution_ledger = ledgerRoot;
-    const reports = [];
+    const serialPrefixLength = executionSerialPrefixLength(options.contract);
+    if (options.maxParallel > 1) {
+        assertParallelSuffixTargetsAreUnique(options.contract, serialPrefixLength);
+    }
+    const reports = new Array(options.contract.actions.length);
     const statuses = new Map();
     const referenceOnlySupportCache = new Map();
-    for (const [index, action] of options.contract.actions.entries()) {
+    const executeAction = async (index) => {
+        const action = options.contract.actions[index];
         const row = options.preparedRows[index];
+        const storeReport = (report) => {
+            reports[index] = report;
+            statuses.set(action.action_id, report.status);
+        };
         const preparedFailure = buildPreparedFailure(row, options.allowReferenceOnlySupport);
         if (preparedFailure) {
             const report = {
@@ -928,9 +979,8 @@ async function runExecutionContractBatch(options) {
                 replayed: false,
                 readback: 'not_performed',
             };
-            reports.push(report);
-            statuses.set(action.action_id, report.status);
-            continue;
+            storeReport(report);
+            return;
         }
         const priorOutcome = ledger.outcomes.get(action.action_id);
         if (priorOutcome) {
@@ -959,9 +1009,8 @@ async function runExecutionContractBatch(options) {
                     }
                     : {}),
             });
-            reports.push(report);
-            statuses.set(action.action_id, status);
-            continue;
+            storeReport(report);
+            return;
         }
         if (ledger.attempts.has(action.action_id)) {
             const report = await finalizeAttemptedAction({
@@ -976,9 +1025,8 @@ async function runExecutionContractBatch(options) {
                 now: options.now,
                 recovered: true,
             });
-            reports.push(report);
-            statuses.set(action.action_id, report.status);
-            continue;
+            storeReport(report);
+            return;
         }
         const blockingDependencies = action.dependency_action_ids.filter((dependency) => statuses.get(dependency) !== 'executed');
         if (blockingDependencies.length > 0) {
@@ -994,9 +1042,8 @@ async function runExecutionContractBatch(options) {
                     details: { dependency_action_ids: blockingDependencies },
                 },
             });
-            reports.push(report);
-            statuses.set(action.action_id, report.status);
-            continue;
+            storeReport(report);
+            return;
         }
         let beforeRows;
         let transportFailed = false;
@@ -1042,6 +1089,11 @@ async function runExecutionContractBatch(options) {
                     });
                 }
             }
+            await renewExecutionOwnerToken({
+                runtime: options.runtime,
+                commandTransport: options.commandTransport,
+                contract: options.contract,
+            });
         }
         catch (error) {
             const report = contractRowReport({
@@ -1053,9 +1105,8 @@ async function runExecutionContractBatch(options) {
                 readback: 'not_performed',
                 error: serializeError(error),
             });
-            reports.push(report);
-            statuses.set(action.action_id, report.status);
-            continue;
+            storeReport(report);
+            return;
         }
         try {
             const beforeDispatch = () => {
@@ -1111,15 +1162,40 @@ async function runExecutionContractBatch(options) {
             now: options.now,
             recovered: transportFailed,
         });
-        reports.push(report);
-        statuses.set(action.action_id, report.status);
+        storeReport(report);
+    };
+    for (let index = 0; index < serialPrefixLength; index += 1) {
+        await executeAction(index);
     }
-    const failures = reports.filter((row) => ['failed', 'unknown', 'blocked'].includes(row.status));
-    writeJsonLinesArtifact(options.files.progress_jsonl, reports);
+    let nextParallelIndex = serialPrefixLength;
+    let fatalWorkerError = null;
+    const runParallelWorker = async () => {
+        while (fatalWorkerError === null) {
+            const index = nextParallelIndex;
+            nextParallelIndex += 1;
+            if (index >= options.contract.actions.length) {
+                return;
+            }
+            try {
+                await executeAction(index);
+            }
+            catch (error) {
+                fatalWorkerError ??= error;
+            }
+        }
+    };
+    const parallelWorkerCount = Math.min(options.maxParallel, options.contract.actions.length - serialPrefixLength);
+    await Promise.all(Array.from({ length: parallelWorkerCount }, () => runParallelWorker()));
+    if (fatalWorkerError !== null) {
+        throw fatalWorkerError;
+    }
+    const completedReports = reports;
+    const failures = completedReports.filter((row) => ['failed', 'unknown', 'blocked'].includes(row.status));
+    writeJsonLinesArtifact(options.files.progress_jsonl, completedReports);
     writeJsonLinesArtifact(options.files.failures_jsonl, failures);
-    const unknown = reports.filter((row) => row.status === 'unknown').length;
-    const failed = reports.filter((row) => row.status === 'failed').length;
-    const blocked = reports.filter((row) => row.status === 'blocked').length;
+    const unknown = completedReports.filter((row) => row.status === 'unknown').length;
+    const failed = completedReports.filter((row) => row.status === 'failed').length;
+    const blocked = completedReports.filter((row) => row.status === 'blocked').length;
     const report = {
         schema_version: 2,
         generated_at_utc: options.now(),
@@ -1136,21 +1212,24 @@ async function runExecutionContractBatch(options) {
         counts: {
             selected: options.preparedRows.length,
             prepared: 0,
-            executed: reports.filter((row) => row.status === 'executed').length,
+            executed: completedReports.filter((row) => row.status === 'executed').length,
             failed,
             unknown,
             blocked,
             attempts_consumed: ledger.attempts.size,
             by_table: byTable(options.preparedRows),
-            operations: operationCount(reports),
+            operations: operationCount(completedReports),
         },
         files: options.files,
-        rows: reports,
+        rows: completedReports,
         execution_contract: {
             path: path.resolve(options.contractPath),
             sha256: contractSha256,
             execution_id: options.contract.execution_id,
             target_mode: 'owner_draft',
+            max_parallel: options.maxParallel,
+            serial_prefix_actions: serialPrefixLength,
+            parallel_suffix_actions: options.contract.actions.length - serialPrefixLength,
         },
     };
     writeJsonArtifact(options.files.summary_json, report);
@@ -1167,6 +1246,7 @@ export async function runDatasetSaveDraft(options) {
     const files = buildFiles(outDir);
     const preparedRows = prepareRows(inputPath, options.rawInput, requestedType);
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxParallel = normalizeExecutionMaxParallel(options.maxParallel);
     const executionContractPath = options.executionContractPath
         ? path.resolve(options.executionContractPath)
         : null;
@@ -1176,6 +1256,9 @@ export async function runDatasetSaveDraft(options) {
     if (executionContract && !commit) {
         executionContractError('Execution contract mode requires --commit.');
     }
+    if (!executionContract && maxParallel !== 1) {
+        executionContractError('--max-parallel greater than 1 requires --execution-contract.');
+    }
     if (executionContract) {
         bindExecutionContractRows(executionContract, preparedRows);
     }
@@ -1221,6 +1304,7 @@ export async function runDatasetSaveDraft(options) {
             fetchImpl: options.fetchImpl,
             timeoutMs,
             now: () => now.toISOString(),
+            maxParallel,
         });
     }
     const reports = [];