@resolveio/server-lib 22.3.214 → 22.3.216

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.214",
+  "version": "22.3.216",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",

package/util/support-runner-v5.js

@@ -130,7 +130,7 @@ function cleanListEntryText(value, max) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
         var source = value;
         var hypothesis = cleanListEntryText(source.hypothesis, Math.floor(max / 2));
-        var whyRejected = cleanListEntryText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.reason, Math.floor(max / 2));
+        var whyRejected = cleanListEntryText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.rejection_reason || source.rejectionReason || source.reason, Math.floor(max / 2));
         if (hypothesis && whyRejected) {
             return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
         }
@@ -148,13 +148,29 @@ function cleanListEntryText(value, max) {
                 'source_file',
                 'artifactPath',
                 'artifact_path',
+                'request_classification',
+                'requestClassification',
+                'classification_rationale',
+                'classificationRationale',
+                'behavior_type',
+                'behaviorType',
                 'summary',
                 'detail',
                 'message',
                 'description',
+                'rationale',
                 'proof_required',
                 'proofRequired',
+                'reported',
+                'verified',
+                'reported_path',
+                'reportedPath',
+                'verified_path',
+                'verifiedPath',
+                'rejection_reason',
+                'rejectionReason',
                 'reason',
+                'fact',
                 'value',
                 'label',
                 'id'
@@ -934,6 +950,10 @@ function normalizeIssueClass(value) {
         customer_inquiry: 'missing_wrong_data',
         data_mismatch: 'missing_wrong_data',
         warehouse_mismatch: 'missing_wrong_data',
+        data_visibility_mapping: 'missing_wrong_data',
+        data_mapping: 'missing_wrong_data',
+        visibility_mapping: 'missing_wrong_data',
+        display_mapping: 'missing_wrong_data',
         route_auth: 'route_auth_hydration',
         auth_hydration: 'route_auth_hydration',
         route_auth_hydration: 'route_auth_hydration',
@@ -946,7 +966,13 @@ function normalizeIssueClass(value) {
         requested_behavior_change: 'missing_wrong_data',
         new_feature: 'missing_wrong_data'
     };
-    return aliases[normalized] || '';
+    if (aliases[normalized]) {
+        return aliases[normalized];
+    }
+    if (/\b(data|field|value|visibility|mapping|display|warehouse|quantity|inventory)\b/i.test(normalized)) {
+        return 'missing_wrong_data';
+    }
+    return '';
 }
 function normalizeReproductionStatus(value) {
     var normalized = cleanText(value, 80).toLowerCase();
@@ -1047,7 +1073,7 @@ function normalizeSupportDiagnosisEvidence(values, ownerFiles) {
         .map(function (entry) {
         var type = cleanText(entry.type, 80).toLowerCase();
         var artifactPath = cleanText(entry.artifactPath || entry.artifact_path || entry.path || entry.file, 500);
-        var summary = cleanText(entry.summary || entry.detail || entry.message || entry.evidence || entry.reason || entry.fact || entry.description || entry.proof_required || entry.proofRequired, 1200)
+        var summary = cleanText(entry.summary || entry.detail || entry.message || entry.evidence || entry.reason || entry.rejection_reason || entry.rejectionReason || entry.fact || entry.description || entry.proof_required || entry.proofRequired, 1200)
             || (artifactPath ? "Evidence from ".concat(artifactPath) : '');
         var evidenceText = [summary, artifactPath].filter(Boolean).join(' ');
         var inferredType = (function () {
@@ -1746,14 +1772,21 @@ function supportDiagnosisNarrativeText(value, max) {
         return '';
     }
     var hypothesis = cleanText(source.hypothesis, Math.floor(max / 2));
-    var whyRejected = cleanText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.reason, Math.floor(max / 2));
+    var whyRejected = cleanText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.rejection_reason || source.rejectionReason || source.reason, Math.floor(max / 2));
     if (hypothesis && whyRejected) {
         return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
     }
     var direct = pickText(source, [
+        'request_classification',
+        'requestClassification',
+        'classification_rationale',
+        'classificationRationale',
+        'behavior_type',
+        'behaviorType',
         'summary',
         'detail',
         'description',
+        'rationale',
         'statement',
         'issue_case',
         'issueCase',
@@ -1766,10 +1799,18 @@ function supportDiagnosisNarrativeText(value, max) {
         'route',
         'path_chain',
         'pathChain',
+        'reported',
+        'verified',
+        'reported_path',
+        'reportedPath',
+        'verified_path',
+        'verifiedPath',
         'assessment',
         'path',
         'proof_required',
         'proofRequired',
+        'rejection_reason',
+        'rejectionReason',
         'reason',
         'fact'
     ], max);
@@ -1779,7 +1820,24 @@ function supportDiagnosisNarrativeText(value, max) {
     var routeModulePermission = cleanText(source.route_module_permission_gate || source.routeModulePermissionGate, Math.floor(max / 2));
     var templateGate = cleanText(source.template_conditional_rendering_gate || source.templateConditionalRenderingGate, Math.floor(max / 2));
     var backingGate = cleanText(source.backing_role_group_config_publications_gate || source.backingRoleGroupConfigPublicationsGate, Math.floor(max / 2));
-    return [routeModulePermission, templateGate, backingGate].filter(Boolean).join(' | ').slice(0, max);
+    var explicitGateText = [routeModulePermission, templateGate, backingGate].filter(Boolean).join(' | ').slice(0, max);
+    if (explicitGateText) {
+        return explicitGateText;
+    }
+    return Object.entries(source)
+        .filter(function (_a) {
+        var _b = __read(_a, 1), key = _b[0];
+        return !/^(id|_id|type|status|updatedAt|updated_at|createdAt|created_at)$/i.test(key);
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 2), entry = _b[1];
+        return cleanListEntryText(entry, Math.max(80, Math.floor(max / 4)));
+    })
+        .filter(Boolean)
+        .join(' | ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, max);
 }
 function supportDiagnosisLooksLikeClassifiedFeatureRequest(source, issueCaseText, failingPathText, hypothesisText) {
     var classificationText = supportDiagnosisNarrativeText(source.classification || source.classification_reason || source.classificationReason, 700);
@@ -1855,12 +1913,86 @@ function normalizeSupportDiagnosisProofPlanRows(values) {
         data_assertion: proofRequired.join(' | ').slice(0, 1000)
     };
 }
+function collectSupportDiagnosisTextListFromValues(values, limit, max) {
+    var e_8, _a, e_9, _b, e_10, _c, e_11, _d;
+    if (limit === void 0) { limit = 10; }
+    if (max === void 0) { max = 800; }
+    var result = [];
+    try {
+        for (var values_5 = __values(values), values_5_1 = values_5.next(); !values_5_1.done; values_5_1 = values_5.next()) {
+            var value = values_5_1.value;
+            var direct = cleanList(value, limit, max);
+            try {
+                for (var direct_1 = (e_9 = void 0, __values(direct)), direct_1_1 = direct_1.next(); !direct_1_1.done; direct_1_1 = direct_1.next()) {
+                    var entry = direct_1_1.value;
+                    if (entry && !result.includes(entry)) {
+                        result.push(entry);
+                    }
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (direct_1_1 && !direct_1_1.done && (_b = direct_1.return)) _b.call(direct_1);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                try {
+                    for (var _e = (e_10 = void 0, __values(Object.entries(value))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var _g = __read(_f.value, 2), key = _g[0], nestedValue = _g[1];
+                        if (!/(evidence|proof|ref|source|code|artifact|fact)/i.test(key)) {
+                            continue;
+                        }
+                        var nestedEntries = Array.isArray(nestedValue)
+                            ? cleanList(nestedValue, limit, max)
+                            : [cleanListEntryText(nestedValue, max)].filter(Boolean);
+                        try {
+                            for (var nestedEntries_1 = (e_11 = void 0, __values(nestedEntries)), nestedEntries_1_1 = nestedEntries_1.next(); !nestedEntries_1_1.done; nestedEntries_1_1 = nestedEntries_1.next()) {
+                                var entry = nestedEntries_1_1.value;
+                                if (entry && !result.includes(entry)) {
+                                    result.push(entry);
+                                }
+                            }
+                        }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                        finally {
+                            try {
+                                if (nestedEntries_1_1 && !nestedEntries_1_1.done && (_d = nestedEntries_1.return)) _d.call(nestedEntries_1);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            }
+            if (result.length >= limit) {
+                break;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (values_5_1 && !values_5_1.done && (_a = values_5.return)) _a.call(values_5);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return result.slice(0, limit);
+}
 function normalizeOwnerFilePath(value) {
-    var e_8, _a;
+    var e_12, _a;
     var normalized = cleanListEntryText(value, 500)
         .replace(/\\/g, '/')
         .replace(/^\.\/+/, '')
         .replace(/^\/+/, '')
+        .replace(/:\d+(?:-\d+)?$/g, '')
         .replace(/\s+$/g, '');
     try {
         for (var _b = __values([
@@ -1881,12 +2013,12 @@ function normalizeOwnerFilePath(value) {
             }
         }
     }
-    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_8) throw e_8.error; }
+        finally { if (e_12) throw e_12.error; }
     }
     return normalized;
 }
@@ -1895,7 +2027,7 @@ function isResolveIOSupportGeneratedAngularWrapperPath(value) {
     return /(?:^|\/)angular\/app\/(?:methods|publications)\.ts$/i.test(normalized);
 }
 function ownerFileComparablePathKeys(value) {
-    var e_9, _a;
+    var e_13, _a;
     var normalized = normalizeOwnerFilePath(value);
     if (!normalized) {
         return [];
@@ -1917,12 +2049,12 @@ function ownerFileComparablePathKeys(value) {
             }
         }
     }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_9) throw e_9.error; }
+        finally { if (e_13) throw e_13.error; }
     }
     return Array.from(keys);
 }
@@ -2345,15 +2477,23 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     var ticketEvidenceText = ((_a = diagnosisEvidence.find(function (entry) { return entry.type === 'ticket'; })) === null || _a === void 0 ? void 0 : _a.summary) || '';
     var browserEvidenceText = ((_b = diagnosisEvidence.find(function (entry) { return entry.type === 'browser'; })) === null || _b === void 0 ? void 0 : _b.summary) || '';
     var rootCauseEvidenceText = ((_c = diagnosisEvidence.find(function (entry) { return SUPPORT_ROOT_CAUSE_EVIDENCE_TYPES.has(entry.type); })) === null || _c === void 0 ? void 0 : _c.summary) || '';
+    var explicitCustomerComplaint = pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200);
     var customerIssueCaseText = (function () {
+        if (explicitCustomerComplaint) {
+            return explicitCustomerComplaint;
+        }
+        var evidenceCustomerText = cleanText([ticketEvidenceText, browserEvidenceText]
+            .filter(Boolean)
+            .join(' '), 1200);
+        if (evidenceCustomerText) {
+            return evidenceCustomerText;
+        }
         var issueText = cleanText(issueCaseText, 1200);
         if (issueText && !supportDiagnosisTextLooksGeneric(issueText, 18)
             && !/\b(general inquiry|existing behavior|not a confirmed runtime failure)\b/i.test(issueText)) {
             return issueText;
         }
-        return cleanText([ticketEvidenceText, browserEvidenceText]
-            .filter(Boolean)
-            .join(' '), 1200);
+        return '';
     })();
     var issueCasePrimaryText = customerIssueCaseText || cleanText([
         rootCauseEvidenceText,
@@ -2362,7 +2502,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     ].filter(Boolean).join(' '), 1200);
     var routeModule = pickText(issueCaseSource, ['route_module', 'routeModule', 'route', 'module', 'screen'], 500)
         || pickText(source, ['route_module', 'routeModule', 'module', 'screen'], 500)
-        || pickText(failingPathSource, ['route', 'module', 'path', 'description'], 500)
+        || pickText(failingPathSource, ['route', 'module', 'path', 'description', 'reported', 'verified', 'reported_path', 'reportedPath', 'verified_path', 'verifiedPath'], 500)
         || failingPathText
         || (featureRequestClassified ? 'net-new support feature workflow' : '');
     var expectedResult = pickText(issueCaseSource, ['expected_result', 'expectedResult', 'expected'], 1000)
@@ -2379,9 +2519,19 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
         || (featureRequestClassified ? 'Customer/account context from support ticket intake.' : '');
     var rawReproductionStatus = issueCaseSource.reproduction_status || issueCaseSource.reproductionStatus || source.reproduction_status;
     var hasRuntimeReproductionEvidence = diagnosisEvidence.some(function (entry) { return SUPPORT_REPRODUCTION_EVIDENCE_TYPES.has(entry.type); });
+    var explicitHypothesisEvidence = collectSupportDiagnosisTextListFromValues([
+        hypothesisSource.evidence,
+        hypothesisSource.evidence_refs,
+        hypothesisSource.evidenceRefs,
+        hypothesisSource.code_evidence,
+        hypothesisSource.codeEvidence,
+        source.hypothesis_evidence,
+        source.hypothesisEvidence,
+        hypothesisSource
+    ], 10, 800);
     var gate = {
         issue_case: {
-            customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200) || customerIssueCaseText,
+            customer_complaint: explicitCustomerComplaint || customerIssueCaseText,
             expected_result: expectedResult,
             observed_result: observedResult,
             route_module: routeModule,
@@ -2397,8 +2547,8 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
                 || hypothesisText,
             falsifiable_test: pickText(hypothesisSource, ['falsifiable_test', 'falsifiableTest', 'test', 'proof', 'falsifier'], 1000)
                 || (failingPathText ? "Verify the accepted hypothesis against the failing path evidence: ".concat(failingPathText) : ''),
-            evidence: cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800).length
-                ? cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800)
+            evidence: explicitHypothesisEvidence.length
+                ? explicitHypothesisEvidence
                 : diagnosisEvidence.map(function (entry) { return [entry.artifactPath, entry.summary].filter(Boolean).join(': '); }).filter(Boolean).slice(0, 10)
         },
         rejected_alternatives: normalizeSupportDiagnosisRejectedAlternatives(source.rejected_alternatives || source.rejectedAlternatives),
@@ -2407,7 +2557,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
             backend: pickText(failingPathSource, ['backend', 'backend_path', 'backendPath', 'methodPublicationPath'], 700),
             shared_library: pickText(failingPathSource, ['shared_library', 'sharedLibrary', 'library', 'lib'], 700),
             data_query: pickText(failingPathSource, ['data_query', 'dataQuery', 'query'], 700),
-            description: pickText(failingPathSource, ['description', 'path_chain', 'pathChain', 'path', 'assessment', 'summary', 'route'], 1200) || failingPathText
+            description: pickText(failingPathSource, ['description', 'path_chain', 'pathChain', 'reported', 'verified', 'reported_path', 'reportedPath', 'verified_path', 'verifiedPath', 'path', 'assessment', 'summary', 'route'], 1200) || failingPathText
         },
         owner_files: ownerFiles,
         proof_plan: {
@@ -2433,7 +2583,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     return gate;
 }
 function extractResolveIOSupportDiagnosisGateFromText(value, now) {
-    var e_10, _a;
+    var e_14, _a;
     var text = String(value || '').trim();
     if (!text) {
         return undefined;
@@ -2461,12 +2611,12 @@ function extractResolveIOSupportDiagnosisGateFromText(value, now) {
             }
         }
     }
-    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
     finally {
         try {
             if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
         }
-        finally { if (e_10) throw e_10.error; }
+        finally { if (e_14) throw e_14.error; }
     }
     return undefined;
 }
@@ -2629,7 +2779,7 @@ function supportStatusLooksPassed(value) {
     return /\b(pass|passed|success|succeeded|complete|completed|ready|not_required|not required)\b/i.test(cleanText(value, 200));
 }
 function nestedObject(source) {
-    var e_11, _a;
+    var e_15, _a;
     var keys = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         keys[_i - 1] = arguments[_i];
@@ -2643,17 +2793,17 @@ function nestedObject(source) {
             }
         }
     }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
     finally {
         try {
             if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
         }
-        finally { if (e_11) throw e_11.error; }
+        finally { if (e_15) throw e_15.error; }
     }
     return {};
 }
 function resolveSupportReplyReleaseGate(input) {
-    var e_12, _a;
+    var e_16, _a;
     var _b;
     var releaseEvidence = cleanObject(input.releaseEvidence);
     var releaseStatus = cleanText(input.releaseStatus
@@ -2724,12 +2874,12 @@ function resolveSupportReplyReleaseGate(input) {
             blockers.push("missing_".concat(field));
         }
     }
-    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
     finally {
         try {
             if (missingCommitProofFields_1_1 && !missingCommitProofFields_1_1.done && (_a = missingCommitProofFields_1.return)) _a.call(missingCommitProofFields_1);
         }
-        finally { if (e_12) throw e_12.error; }
+        finally { if (e_16) throw e_16.error; }
     }
     var shouldEvaluateHotfix = statusBlocked || commitProofRequired || Object.keys(hotfixEvidence).length > 0;
     var hotfixContinuation = shouldEvaluateHotfix
@@ -2775,7 +2925,7 @@ function supportBusinessAssertionRouteOnly(value) {
     return /^(route_probe_pass|route_only_pass|route_pass|route_probe|route_loaded)$/i.test(cleanText(value, 80));
 }
 function normalizeSupportBusinessProofAssertions(input) {
-    var e_13, _a;
+    var e_17, _a;
     var gate = normalizeResolveIOSupportDiagnosisGate(input.diagnosisGate);
     var proofPlan = gate === null || gate === void 0 ? void 0 : gate.proof_plan;
     var proofContract = proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.business_proof_contract;
@@ -2809,12 +2959,12 @@ function normalizeSupportBusinessProofAssertions(input) {
             });
         }
     }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_13) throw e_13.error; }
+        finally { if (e_17) throw e_17.error; }
     }
     var status = cleanText(input.businessAssertionStatus || input.outcomeLabel, 80);
     if (!assertions.length && (supportBusinessAssertionPassed(status) || supportBusinessAssertionRouteOnly(status) || supportBusinessAssertionFailed(status))) {
@@ -2904,7 +3054,7 @@ function supportBusinessProofAssertionHasStructuredContractMapping(assertion, ga
     return routeMatches && actionMatches && expectedStateMatches && hasBusinessDataProof;
 }
 function supportBusinessProofAssertionMatchesContract(assertion, gate) {
-    var e_14, _a;
+    var e_18, _a;
     if (!gate) {
         return false;
     }
@@ -2944,12 +3094,12 @@ function supportBusinessProofAssertionMatchesContract(assertion, gate) {
             }
         }
     }
-    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
     finally {
         try {
             if (proofWords_1_1 && !proofWords_1_1.done && (_a = proofWords_1.return)) _a.call(proofWords_1);
         }
-        finally { if (e_14) throw e_14.error; }
+        finally { if (e_18) throw e_18.error; }
     }
     return overlap >= Math.min(5, Math.max(3, Math.ceil(proofWords.size * 0.45)));
 }
@@ -4474,7 +4624,7 @@ function supportManagerRequiredResetEvidenceForContract(contract) {
     ], false))).slice(0, 16);
 }
 function validateResolveIOSupportNextActionContract(value) {
-    var e_15, _a;
+    var e_19, _a;
     var _b, _c, _d, _e, _f;
     var contract = cleanObject(value);
     var blockers = [];
@@ -4496,12 +4646,12 @@ function validateResolveIOSupportNextActionContract(value) {
             }
         }
     }
-    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
     finally {
         try {
             if (requiredStringFields_1_1 && !requiredStringFields_1_1.done && (_a = requiredStringFields_1.return)) _a.call(requiredStringFields_1);
         }
-        finally { if (e_15) throw e_15.error; }
+        finally { if (e_19) throw e_19.error; }
     }
     if (!Array.isArray(contract.nextCommands) || !contract.nextCommands.length) {
         blockers.push('NextActionContract.nextCommands must include at least the primary command.');
@@ -5520,7 +5670,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_16, _a;
+    var e_20, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -5531,12 +5681,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    catch (e_20_1) { e_20 = { error: e_20_1 }; }
     finally {
         try {
             if (existing_1_1 && !existing_1_1.done && (_a = existing_1.return)) _a.call(existing_1);
         }
-        finally { if (e_16) throw e_16.error; }
+        finally { if (e_20) throw e_20.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -7340,7 +7490,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_17, _a, e_18, _b;
+    var e_21, _a, e_22, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -7355,17 +7505,17 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             existing.calls += 1;
             byMicrotask.set(usage.microtaskId, existing);
             try {
-                for (var _e = (e_18 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_22 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
                     var section = _f.value;
                     bySection.set(section.name, (bySection.get(section.name) || 0) + section.tokenEstimate);
                 }
             }
-            catch (e_18_1) { e_18 = { error: e_18_1 }; }
+            catch (e_22_1) { e_22 = { error: e_22_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_18) throw e_18.error; }
+                finally { if (e_22) throw e_22.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -7373,12 +7523,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_17) throw e_17.error; }
+        finally { if (e_21) throw e_21.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,