nucleus-core-ts 0.10.136 → 0.10.137

package/dist/.build-ok

@@ -1 +1 @@
-0.10.136
+0.10.137

package/dist/fe/components/VerificationFlowPage/components/PendingTab.js

@@ -474,6 +474,13 @@ export function PendingTab({ pendingAction, decideAction, uploadSignatureAction,
                             className: theme.pending.card.subtitle,
                             children: item.step_name
                         }) : null,
+                        item.sent_back?.reason ? /*#__PURE__*/ _jsxs("p", {
+                            className: theme.pending.card.decisionMeta,
+                            children: [
+                                typeof item.pass_no === 'number' && typeof item.max_passes === 'number' ? `${say.pendingRound(item.pass_no, item.max_passes)} · ` : null,
+                                say.previousRoundReason(item.sent_back.reason)
+                            ]
+                        }) : null,
                         renderRecord(item)
                     ]
                 }),

package/dist/fe/components/VerificationFlowPage/components/VerificationFlowPage.js

@@ -316,6 +316,7 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
    * a ref here, because the render needs it too — to tell this editor's save
    * from one left behind — and a ref restarted at 0 on each mount.
    */ /** The latest readiness question; any older answer is about another graph. */ const feasibilityTicketRef = useRef(0);
+    /** The pending automatic re-check after an edit; see `scheduleFeasibility`. */ const feasibilityTimerRef = useRef(null);
     /*
    * The id a NEW flow is saved under, minted at its first save and reused
    * until one succeeds. It is not written to `selectedFlowId` before then:
@@ -756,22 +757,40 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
             }
         });
     });
+    /*
+   * Re-ask once the author PAUSES, with the graph they paused on.
+   *
+   * The answer was dropped on every edit and came back only on "Şimdi kontrol
+   * et" or a save, so adding a third step left the card blank ("henüz
+   * karşılaştırılmadı") exactly when it should have turned red (found by the
+   * re-check). A request per keystroke is not the fix either; one request
+   * 700ms after the last edit is. The ticket still discards an answer that
+   * lands after a newer edit.
+   */ const scheduleFeasibility = useEffectEvent(()=>{
+        if (feasibilityTimerRef.current) clearTimeout(feasibilityTimerRef.current);
+        feasibilityTimerRef.current = setTimeout(()=>{
+            feasibilityTimerRef.current = null;
+            checkFeasibility();
+        }, 700);
+    });
+    useEffect(()=>()=>{
+            if (feasibilityTimerRef.current) clearTimeout(feasibilityTimerRef.current);
+        }, []);
     const handleModel2Change = useEffectEvent((next, notes)=>{
         store.setModel2Graph(next);
         if (notes.length > 0) store.setModel2Notes(notes);
         store.markEdited();
-        /*
-     * The readiness answer is about a graph that no longer exists the moment an
-     * edit lands, so it is dropped rather than left on screen. Re-asking on
-     * every keystroke would be a request per character; the author asks again
-     * with the button, and a save always re-asks on the server anyway.
-     */ dropFeasibility();
+        // The old answer is about a graph that no longer exists: drop it now,
+        // re-ask when the author pauses.
+        dropFeasibility();
+        scheduleFeasibility();
     });
     const handleMaxPassesChange = useEffectEvent((value)=>{
         store.setMaxPasses(value);
         store.markEdited();
         // The round limit is part of the question the card answered.
         dropFeasibility();
+        scheduleFeasibility();
     });
     // ─── Flow details ─────────────────────────────────────────────
     //

package/dist/fe/components/VerificationFlowPage/labels.d.ts

@@ -443,6 +443,8 @@ export type VerificationFlowLabels = {
     reviewStartedNote: string;
     /** On the reviewer's card: which round, and what Reject will do. */
     pendingRound: (pass: number, max: number) => string;
+    /** On a reviewer's card in a later round: why the previous round was rejected. */
+    previousRoundReason: (reason: string) => string;
     pendingRejectSendsBack: (stepLabel: string) => string;
     pendingRejectEndsReview: string;
     pendingLastRoundWarning: string;

package/dist/fe/components/VerificationFlowPage/labels.js

@@ -235,7 +235,7 @@
     approvalModeAll: 'Everyone listed',
     approvalModeAllHint: 'Every person above must decide before the record moves on.',
     approvalModeAny: 'Any one of them',
-    approvalModeAnyHint: 'The first decision closes the step, and the others are no longer asked.',
+    approvalModeAnyHint: 'The first person listed to finish closes the step, and the others are no longer asked. A role set to "every member" finishes only when all its members have signed.',
     outcomes: 'Where each answer sends it',
     onApproved: 'If approved',
     onApprovedNext: 'Go to the next step',
@@ -320,6 +320,7 @@
     startReviewFailed: 'The review could not be started.',
     reviewStartedNote: 'Sent for review.',
     pendingRound: (pass, max)=>`Round ${pass} (at most ${max})`,
+    previousRoundReason: (reason)=>`Rejected last round because: ${reason}`,
     pendingRejectSendsBack: (stepLabel)=>`Rejecting sends this back to ${stepLabel}.`,
     pendingRejectEndsReview: 'Rejecting ends this review.',
     pendingLastRoundWarning: 'This is the last round this flow allows, so rejecting now ends the review for good — the record will not go back to its author again.',
@@ -431,7 +432,12 @@ export function recipientTypeLabels(say) {
 // one, the engine's sentence when it does not, and a generic line only when
 // the engine sent nothing at all.
 export function refusalSentence(say, code, detail, fallback, generic) {
-    const own = code ? say.flowRefusalByCode[code] : undefined;
+    /*
+   * Publish refuses with the READINESS codes too (a chain needing more people
+   * than the install has). A host that worded those only for the readiness
+   * card got the English sentence in the publish banner — measured by the
+   * re-check on the Turkish panel.
+   */ const own = code ? say.flowRefusalByCode[code] ?? say.feasibilityByCode[code] : undefined;
     if (own) return own(detail ?? {});
     const decision = code ? say.decisionRefusalByCode[code] : undefined;
     if (decision) return decision;

package/dist/fe/components/VerificationFlowPage/model2/StepCard.js

@@ -251,7 +251,9 @@ export function StepCard({ step, graph, isFirst, isLast, roles, users, triggerLa
                                     step_node_id: step.node_id
                                 },
                                 actions: stepActions,
-                                triggers: STEP_TRIGGERS,
+                                // "The author sent it back" can only happen on the author's own
+                                // correction step; offered elsewhere it saved and never fired.
+                                triggers: (step.kind ?? 'approval') === 'revision' ? STEP_TRIGGERS : STEP_TRIGGERS.filter((t)=>t !== 'on_resubmitted'),
                                 triggerLabels: triggerLabels,
                                 recipientTypeLabels: recipientTypeLabels,
                                 channelLabels: channelLabels,

package/dist/fe/components/VerificationFlowPage/model2/editorGraph.js

@@ -412,7 +412,15 @@ export function updateActionAt(graph, index, patch) {
 /** The steps an approval on `nodeId` may skip to: strictly later ones. */ export function approveTargets(graph, nodeId) {
     const step = (graph.steps ?? []).find((s)=>s.node_id === nodeId);
     if (!step) return [];
-    return (graph.steps ?? []).filter((s)=>s.step_order > step.step_order).sort(byOrder);
+    const later = (graph.steps ?? []).filter((s)=>s.step_order > step.step_order).sort(byOrder);
+    if ((step.kind ?? 'approval') !== 'revision') return later;
+    /*
+   * A correction step may not jump OVER a reviewer. Two correction steps at
+   * the front with different jumps gave each round a different entry, and a
+   * reviewer walked in round 1 but jumped over in round 2 kept a signature on
+   * the old text (found by the re-check). Mirrors `revision_skips_reviewers`.
+   */ const firstReviewer = later.find((s)=>(s.kind ?? 'approval') !== 'revision');
+    return firstReviewer ? later.filter((s)=>s.step_order <= firstReviewer.step_order) : later;
 }
 /**
  * The approval outcomes the step card may OFFER for `nodeId`.
@@ -547,10 +555,12 @@ export const MAX_PASSES_MAX = 20;
  * first (found in the audit). Telling the author the two buttons do the same
  * thing there is telling them a choice that matters does not.
  */ export function approvalModeHasNoEffect(step) {
-    const slots = step.assignees ?? [];
-    if (slots.length !== 1) return false;
-    const only = slots[0];
-    return !(only?.verifier_type === 'role' && only.role_quorum === 'all');
+    /*
+   * The engine reads "any one of them" as any one SLOT, and a slot of "every
+   * member" is finished only when every member has signed (0.10.135). So with
+   * ONE slot the two modes are the same rule whatever its quorum — the
+   * exception this carried described the engine before that fix.
+   */ return (step.assignees ?? []).length === 1;
 }
 /**
  * The part of a step patch a live flow still accepts: its wording.