nucleus-core-ts 0.10.129 → 0.10.130

package/dist/.build-ok

@@ -1 +1 @@
-0.10.129
+0.10.130

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

@@ -1,4 +1,4 @@
 import '@xyflow/react/dist/style.css';
 import type { ReactElement } from 'react';
 import type { VerificationFlowPageProps } from '../types';
-export declare function VerificationFlowPage({ entityName, title, subtitle, flowListAction, flowGetAction, flowSaveAction, flowPublishAction, flowUnpublishAction, flowDeleteAction, pendingAction, decideAction, uploadSignatureAction, listUsersAction, listRolesAction, entityStatusesAction, onFlowSelected, onDecisionMade, onEntityClick, onBack, showPending, showEntityStatuses, className, themeMode, labels, describeEntity, entityHref, availableChannels, initialTab, cancelAction, }: VerificationFlowPageProps): ReactElement;
+export declare function VerificationFlowPage({ entityName, title, subtitle, flowListAction, flowGetAction, flowSaveAction, flowPublishAction, flowUnpublishAction, flowDeleteAction, pendingAction, decideAction, uploadSignatureAction, listUsersAction, listRolesAction, entityStatusesAction, onFlowSelected, onDecisionMade, onEntityClick, onBack, showPending, showEntityStatuses, className, themeMode, labels, describeEntity, entityHref, availableChannels, initialTab, cancelAction, authoringModel, flowFeasibilityAction, manageRolesHref, }: VerificationFlowPageProps): ReactElement;

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

@@ -5,7 +5,10 @@ import '@xyflow/react/dist/style.css';
 import { useEffect, useEffectEvent, useRef, useState } from 'react';
 import { cn } from '../../../utils/cn';
 import { newId } from '../../../utils/newId';
-import { DEFAULT_VERIFICATION_FLOW_LABELS, setActiveLabels } from '../labels';
+import { DEFAULT_VERIFICATION_FLOW_LABELS, notificationChannelLabels, notificationTriggerLabels, recipientTypeLabels, setActiveLabels } from '../labels';
+import { emptyModel2Graph } from '../model2/editorGraph';
+import { StepListEditor } from '../model2/StepListEditor';
+import { getModel2Theme } from '../model2/theme';
 import { assignStepOrders } from '../stepOrder';
 import { useVerificationFlowStore } from '../store';
 import { getVerificationFlowTheme } from '../theme';
@@ -281,7 +284,7 @@ function buildSavePayload(flowId, entityName, flowName, flowDescription, trigger
     };
 }
 // ─── Main Component ───────────────────────────────────────────────
-export function VerificationFlowPage({ entityName, title, subtitle, flowListAction, flowGetAction, flowSaveAction, flowPublishAction, flowUnpublishAction, flowDeleteAction, pendingAction, decideAction, uploadSignatureAction, listUsersAction, listRolesAction, entityStatusesAction, onFlowSelected, onDecisionMade, onEntityClick, onBack, showPending = true, showEntityStatuses = false, className, themeMode = 'dark', labels, describeEntity, entityHref, availableChannels, initialTab, cancelAction }) {
+export function VerificationFlowPage({ entityName, title, subtitle, flowListAction, flowGetAction, flowSaveAction, flowPublishAction, flowUnpublishAction, flowDeleteAction, pendingAction, decideAction, uploadSignatureAction, listUsersAction, listRolesAction, entityStatusesAction, onFlowSelected, onDecisionMade, onEntityClick, onBack, showPending = true, showEntityStatuses = false, className, themeMode = 'dark', labels, describeEntity, entityHref, availableChannels, initialTab, cancelAction, authoringModel = 1, flowFeasibilityAction, manageRolesHref }) {
     const theme = getVerificationFlowTheme(themeMode);
     setActiveTheme(theme);
     const say = {
@@ -304,6 +307,15 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
     const [showCreateForm, setShowCreateForm] = useState(false);
     const reactFlowWrapper = useRef(null);
     const reactFlowInstance = useRef(null);
+    /*
+   * Which editor is on screen — NOT which one the host prefers.
+   *
+   * An existing flow always opens in the editor it was written in, decided by
+   * the `model_version` the server sends back, because opening a drawn flow in
+   * the list editor would show an empty chain for a flow that has three steps.
+   * `authoringModel` only decides what the CREATE button makes.
+   */ const [isModel2, setIsModel2] = useState(false);
+    const m2Theme = getModel2Theme(themeMode);
     const resolvedTitle = title || say.pageTitle(entityName);
     const resolvedSubtitle = subtitle || entityName;
     // ─── Node/Edge Change Handlers ────────────────────────────────
@@ -400,6 +412,54 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
         }
         const name = flowName || say.defaultFlowName(entityName);
         store.setIsSaving(true);
+        /*
+     * An authored chain sends a DIFFERENT body, and `graph` goes out empty
+     * beside it. The server reads `model2` only when `model_version` is 2, and
+     * `graph` only when it is not — sending both filled would leave the
+     * question of which one is the flow to whichever reader ran last.
+     */ if (isModel2) {
+            flowSaveAction.start({
+                payload: {
+                    flow_id: flowId,
+                    entity_name: entityName,
+                    name,
+                    description: flowDescription || undefined,
+                    trigger_on: flowTriggerOn,
+                    is_draft: true,
+                    model_version: 2,
+                    max_passes: store.maxPasses,
+                    model2: store.model2Graph,
+                    graph: {
+                        steps: [],
+                        edges: [],
+                        verifier_configs: [],
+                        notification_rules: [],
+                        notification_recipients: [],
+                        notification_channels: []
+                    }
+                },
+                onAfterHandle: (res)=>{
+                    const resObj = res;
+                    store.setIsSaving(false);
+                    if (resObj.success === false) {
+                        // Refused. The chain on screen was NOT written, so the editor stays
+                        // dirty — clearing it here would tell the author their work is saved.
+                        store.setError(resObj.message || say.saveRefused);
+                        return;
+                    }
+                    store.setError(null);
+                    if (resObj.flow_id) store.setSelectedFlowId(resObj.flow_id);
+                    store.setIsDirty(false);
+                    loadFlows();
+                },
+                onErrorHandle: (err)=>{
+                    store.setIsSaving(false);
+                    const e = err;
+                    store.setError(e?.message || say.saveRefused);
+                }
+            });
+            return;
+        }
         const viewport = reactFlowInstance.current ? reactFlowInstance.current.getViewport() : undefined;
         const payload = buildSavePayload(flowId, entityName, name, flowDescription, flowTriggerOn, true, viewport, nodes, edges);
         flowSaveAction.start({
@@ -492,6 +552,56 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
             }
         });
     });
+    // ─── The authored chain ───────────────────────────────────────
+    /*
+   * Asked of the graph on screen, not of the stored flow.
+   *
+   * The moment the answer is worth anything is while the author is still
+   * editing. An endpoint that only answered for saved flows would mean saving a
+   * flow you already suspect is broken in order to find out whether it is.
+   */ const checkFeasibility = useEffectEvent(()=>{
+        if (!flowFeasibilityAction) return;
+        if ((store.model2Graph.steps ?? []).length === 0) {
+            store.setFeasibility(null);
+            return;
+        }
+        store.setFeasibilityLoading(true);
+        store.setFeasibilityError(null);
+        flowFeasibilityAction.start({
+            payload: {
+                entity_name: entityName,
+                max_passes: store.maxPasses,
+                model2: store.model2Graph
+            },
+            onAfterHandle: (res)=>{
+                store.setFeasibilityLoading(false);
+                const data = res?.data;
+                store.setFeasibility(data ?? null);
+            },
+            onErrorHandle: (err)=>{
+                store.setFeasibilityLoading(false);
+                const e = err;
+                /*
+         * The check failing is not the same as the flow being fine. Reported as
+         * its own line rather than left as a stale green card — a readiness
+         * panel that keeps showing the last good answer after it stopped being
+         * able to ask is worse than one that says it could not ask.
+         */ store.setFeasibilityError(e?.message || say.readinessSaveRefusal);
+                store.setFeasibility(null);
+            }
+        });
+    });
+    const handleModel2Change = useEffectEvent((next, notes)=>{
+        store.setModel2Graph(next);
+        if (notes.length > 0) store.setModel2Notes(notes);
+        store.setIsDirty(true);
+        /*
+     * 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.
+     */ store.setFeasibility(null);
+    });
     // ─── View Mode Handlers ──────────────────────────────────────
     const openDesigner = useEffectEvent((flowId)=>{
         store.setSelectedFlowId(flowId);
@@ -508,6 +618,11 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
         store.setSelectedFlowId(null);
         setNodes([]);
         setEdges([]);
+        setIsModel2(authoringModel === 2);
+        store.setModel2Graph(emptyModel2Graph());
+        store.clearModel2Notes();
+        store.setFeasibility(null);
+        store.setMaxPasses(3);
         store.setIsDirty(true);
         setShowCreateForm(false);
         setViewMode('designer');
@@ -554,6 +669,24 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
                     setFlowDescription(flow.description || '');
                     setFlowTriggerOn(flow.trigger_on || 'create');
                 }
+                /*
+         * The STORED model decides which editor opens, not the host's
+         * preference. A model-2 flow read into the drawn editor would render an
+         * empty canvas for a chain that has three steps, and the author's next
+         * save would write that emptiness back.
+         */ const model2 = resObj.data?.model2;
+                if (model2) {
+                    setIsModel2(true);
+                    store.setModel2Graph(model2);
+                    store.setMaxPasses(Number(flow?.max_passes ?? 3));
+                    store.setFeasibility(null);
+                    store.clearModel2Notes();
+                    setNodes([]);
+                    setEdges([]);
+                    store.setLoadingGraph(false);
+                    return;
+                }
+                setIsModel2(false);
                 const graph = resObj.data?.graph;
                 if (graph?.steps && graph.steps.length > 0) {
                     store.setGraphData(graph);
@@ -643,6 +776,19 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
     }, [
         store.selectedFlowId
     ]);
+    /*
+   * Roles and people are loaded when the AUTHORED editor opens, not on mount.
+   *
+   * On mount would mean two directory requests on every visit to a screen most
+   * people open to look at the pending queue, and the pickers those lists feed
+   * do not exist unless the list editor is on screen. Loaded once per opening
+   * rather than per step card — see `loadDirectories`.
+   */ useEffect(()=>{
+        if (viewMode === 'designer' && isModel2) loadDirectories();
+    }, [
+        viewMode,
+        isModel2
+    ]);
     // ─── Derived State ────────────────────────────────────────────
     const selectedFlow = store.flows.find((f)=>f.id === store.selectedFlowId);
     const selectedNode = store.selectedNodeId ? nodes.find((n)=>n.id === store.selectedNodeId) || null : null;
@@ -675,6 +821,73 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
         delete: say.triggerOnDelete,
         manual: say.triggerOnManual
     };
+    /*
+   * The enum → label maps the authored editor needs, built from the same
+   * functions the drawn editor's panel uses. Two maps would be two spellings of
+   * `on_step_reached` on two screens of one product.
+   */ const notifTriggerLabels = notificationTriggerLabels(say);
+    const recipientLabels = recipientTypeLabels(say);
+    const channelLabelMap = notificationChannelLabels(say);
+    /*
+   * Roles and people, once, for the whole authored editor.
+   *
+   * The drawn editor's properties panel fetches its own and caches them in
+   * module scope, because it is mounted and unmounted as nodes are selected.
+   * The list editor shows every step at once, so a fetch per step card would be
+   * one request per step — and every assignee picker would be a separately
+   * paginated list of the same twenty people.
+   *
+   * A high limit rather than pagination: these pickers name reviewers, and a
+   * role that is on page two of the list is a role an author cannot choose.
+   * When an install outgrows this the readiness card is what catches it — a
+   * slot pointing at nothing is blocking there.
+   */ const [roleOptions, setRoleOptions] = useState([]);
+    const [userOptions, setUserOptions] = useState([]);
+    const loadDirectories = useEffectEvent(()=>{
+        if (listRolesAction) {
+            listRolesAction.start({
+                payload: {
+                    page: 1,
+                    limit: 200
+                },
+                onAfterHandle: (res)=>{
+                    const dataObj = res?.data;
+                    const items = dataObj?.items || dataObj?.data || [];
+                    setRoleOptions(items.map((r)=>({
+                            id: r.id,
+                            name: r.name
+                        })));
+                },
+                onErrorHandle: ()=>{
+                    setRoleOptions([]);
+                }
+            });
+        }
+        if (listUsersAction) {
+            listUsersAction.start({
+                payload: {
+                    page: 1,
+                    limit: 200
+                },
+                onAfterHandle: (res)=>{
+                    const dataObj = res?.data;
+                    const items = dataObj?.items || dataObj?.data || [];
+                    /*
+           * A person with no display name still has to be pickable, and by
+           * something a human recognises. The e-mail is that; the id is not —
+           * a reviewer chosen by uuid is a reviewer nobody can verify was the
+           * right one.
+           */ setUserOptions(items.map((u)=>({
+                            id: u.id,
+                            name: u.name || u.email || u.id
+                        })));
+                },
+                onErrorHandle: ()=>{
+                    setUserOptions([]);
+                }
+            });
+        }
+    });
     // ─── Render ───────────────────────────────────────────────────
     return /*#__PURE__*/ _jsxs("div", {
         className: cn(theme.layout.root, className),
@@ -1111,7 +1324,37 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
                     })
                 ]
             }),
-            viewMode === 'designer' && store.activeTab === 'flow' && /*#__PURE__*/ _jsxs("div", {
+            viewMode === 'designer' && store.activeTab === 'flow' && isModel2 && /*#__PURE__*/ _jsx(StepListEditor, {
+                graph: store.model2Graph,
+                maxPasses: store.maxPasses,
+                notes: store.model2Notes,
+                roles: roleOptions,
+                users: userOptions,
+                triggerLabels: notifTriggerLabels,
+                recipientTypeLabels: recipientLabels,
+                channelLabels: channelLabelMap,
+                availableChannels: availableChannels,
+                feasibility: store.feasibility,
+                isCheckingFeasibility: store.isCheckingFeasibility,
+                feasibilityError: store.feasibilityError,
+                manageRolesHref: manageRolesHref,
+                diagramOpen: store.diagramOpen,
+                say: say,
+                theme: m2Theme,
+                themeMode: themeMode,
+                disabled: false,
+                newStepId: newId,
+                onGraphChange: handleModel2Change,
+                onMaxPassesChange: (v)=>{
+                    store.setMaxPasses(v);
+                    store.setIsDirty(true);
+                },
+                onDismissNotes: store.clearModel2Notes,
+                onToggleDiagram: ()=>store.setDiagramOpen(!store.diagramOpen),
+                onRecheckFeasibility: checkFeasibility,
+                confirmRemoveStep: (step)=>typeof window === 'undefined' ? true : window.confirm(say.removeStepConfirm(step.name || say.stepNumber(step.step_order)))
+            }),
+            viewMode === 'designer' && store.activeTab === 'flow' && !isModel2 && /*#__PURE__*/ _jsxs("div", {
                 className: theme.layout.main,
                 children: [
                     /*#__PURE__*/ _jsx("aside", {

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

@@ -6,6 +6,13 @@ export { VerificationEntityList, type VerificationEntityListProps, type Verifica
 export { VerificationFlowPage } from './components/VerificationFlowPage';
 export { VerificationStatusCard, type VerificationStatusCardProps, type VerificationStatusCardTheme, } from './components/VerificationStatusCard';
 export { DEFAULT_VERIFICATION_FLOW_LABELS, type VerificationFlowLabels, } from './labels';
+/**
+ * The authored-chain editor. Exported whole, because a host that wants a
+ * different arrangement of the same blocks — the readiness card beside the
+ * list, say, or the diagram on its own screen — can only have it if the pieces
+ * are reachable.
+ */
+export * from './model2';
 export { useVerificationFlowStore } from './store';
 export type { VerificationFlowPageTheme } from './theme';
 export { extendVerificationFlowPageTheme, getVerificationFlowTheme, verificationFlowPageLightTheme, verificationFlowPageTheme, } from './theme';

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

@@ -6,5 +6,11 @@ export { VerificationEntityList } from './components/VerificationEntityList';
 export { VerificationFlowPage } from './components/VerificationFlowPage';
 export { VerificationStatusCard } from './components/VerificationStatusCard';
 export { DEFAULT_VERIFICATION_FLOW_LABELS } from './labels';
+/**
+ * The authored-chain editor. Exported whole, because a host that wants a
+ * different arrangement of the same blocks — the readiness card beside the
+ * list, say, or the diagram on its own screen — can only have it if the pieces
+ * are reachable.
+ */ export * from './model2';
 export { useVerificationFlowStore } from './store';
 export { extendVerificationFlowPageTheme, getVerificationFlowTheme, verificationFlowPageLightTheme, verificationFlowPageTheme } from './theme';

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

@@ -260,6 +260,155 @@ export type VerificationFlowLabels = {
      * 8/5/2026, which a reader in Turkey reads as the 8th of May. Naming the
      * locale makes both passes agree and both readers right.
      */
+    /** The editor's own heading and the one-line explanation under it. */
+    authoredTitle: string;
+    authoredSubtitle: string;
+    /** The button that adds a step to the end of the list. */
+    addStep: string;
+    addStepFirst: string;
+    /** An empty chain. */
+    authoredEmptyTitle: string;
+    authoredEmptyBody: string;
+    /** The step card. */
+    stepNumber: (order: number) => string;
+    stepNamePlaceholder: (order: number) => string;
+    stepDescriptionPlaceholder: string;
+    moveStepUp: string;
+    moveStepDown: string;
+    removeStep: string;
+    removeStepConfirm: (name: string) => string;
+    /** What kind of step this is. */
+    stepKind: string;
+    stepKindApproval: string;
+    stepKindApprovalHint: string;
+    stepKindRevision: string;
+    stepKindRevisionHint: string;
+    /** Who is asked. */
+    assignees: string;
+    assigneesEmpty: string;
+    addAssignee: string;
+    removeAssignee: string;
+    assigneeTypeRole: string;
+    assigneeTypeUser: string;
+    assigneeTypeAuthor: string;
+    assigneeTypeAuthorHint: string;
+    pickRole: string;
+    pickUser: string;
+    roleQuorum: string;
+    roleQuorumOne: string;
+    roleQuorumOneHint: string;
+    roleQuorumAll: string;
+    roleQuorumAllHint: string;
+    requireSignatureHint: string;
+    /** How many of them have to decide. */
+    approvalMode: string;
+    approvalModeAll: string;
+    approvalModeAllHint: string;
+    approvalModeAny: string;
+    approvalModeAnyHint: string;
+    /** Where each outcome sends the record. */
+    outcomes: string;
+    onApproved: string;
+    onApprovedNext: string;
+    onApprovedComplete: string;
+    onApprovedGoto: string;
+    onRejected: string;
+    onRejectedEnd: string;
+    onRejectedGoto: string;
+    outcomeTargetPlaceholder: string;
+    /** A step in a dropdown of targets. */
+    stepOption: (order: number, name?: string) => string;
+    noEarlierStep: string;
+    noLaterStep: string;
+    /** The loop. */
+    maxPasses: string;
+    maxPassesHint: string;
+    maxPassesValue: (n: number) => string;
+    /** The actions plane. */
+    actions: string;
+    flowActions: string;
+    flowActionsHint: string;
+    stepActions: string;
+    addAction: string;
+    removeAction: string;
+    actionsEmpty: string;
+    actionTrigger: string;
+    actionRecipients: string;
+    actionRecipientsEmpty: string;
+    addRecipient: string;
+    actionChannels: string;
+    actionEnabled: string;
+    actionDisabled: string;
+    actionFiresOnPass: string;
+    actionFiresEvery: string;
+    actionFiresFirst: string;
+    actionFiresRepeat: string;
+    actionTitleTemplate: string;
+    actionBodyTemplate: string;
+    actionWindow: string;
+    actionStartsAt: string;
+    actionExpiresAt: string;
+    actionTemplateHint: string;
+    /** The new triggers model 1 did not have. */
+    notifyTriggerFlowRejected: string;
+    notifyTriggerResubmitted: string;
+    /** The readiness card. */
+    readinessTitle: string;
+    readinessChecking: string;
+    readinessOk: string;
+    readinessBlocked: (count: number) => string;
+    readinessWarnings: (count: number) => string;
+    readinessRecheck: string;
+    readinessStepNeeds: (decisions: number, people: number) => string;
+    readinessChainNeeds: (needed: number, available: number) => string;
+    readinessSlotPeople: (count: number) => string;
+    readinessSlotDeferred: string;
+    readinessSaveRefusal: string;
+    /** Where to go and fix a staffing problem, when the host says there is a screen. */
+    readinessManageRoles: string;
+    /** The notes an edit produces. */
+    editNoteRejectTargetCleared: (stepName: string) => string;
+    editNoteApproveTargetCleared: (stepName: string) => string;
+    editNoteLastStepCompletes: (stepName: string) => string;
+    editNoteCompletionHandedOver: (stepName: string) => string;
+    editNoteActionsDropped: (count: number) => string;
+    editNotesDismiss: string;
+    /** The generated diagram. */
+    diagramTitle: string;
+    diagramHint: string;
+    diagramShow: string;
+    diagramHide: string;
+    /** The question the per-assignee type picker asks. Not the block title. */
+    assigneeTypeLabel: string;
+    /** Names one slot for a screen reader walking the rows. */
+    assigneeSlot: (index: number) => string;
+    /** Shown when a step has 0 or 1 assignees, where the two modes do the same thing. */
+    approvalModeNoEffectHint: string;
+    /** The per-row remove control in an action's recipient list. */
+    removeRecipient: string;
+    /** How many characters are left in a notification title. */
+    actionTitleRemaining: (remaining: number) => string;
+    /** Guidance under the every/first/repeat chips. About the ACTION, not the loop limit. */
+    actionFiresOnPassHint: string;
+    /** The readiness answer when the check itself could not be made. */
+    readinessUnclear: string;
+    /** Announced before a blocking finding, since red is not available to everyone. */
+    readinessBlockingLabel: string;
+    /** Announced before a warning. */
+    readinessWarningLabel: string;
+    /** Both counts at once, for the head line when a flow has blocking AND warnings. */
+    readinessBlockedAndWarned: (blocking: number, warnings: number) => string;
+    /** In the diagram: a step nobody is assigned to. Must be SHORT; svg text does not wrap. */
+    diagramNobodyDecides: string;
+    /** In the diagram: how many people this step asks. Must be SHORT. */
+    diagramAssigneeCount: (count: number) => string;
+    /** In the diagram's text alternative: an approval that skips ahead. */
+    diagramSkipsTo: (stepLabel: string) => string;
+    /** In the diagram's text alternative: a rejection that goes back. */
+    diagramSendsBackTo: (stepLabel: string) => string;
+    /** In the diagram's text alternative: the chain finishing approved / rejected. */
+    diagramFinishesApproved: string;
+    diagramFinishesRejected: string;
     locale: string;
 };
 export declare const DEFAULT_VERIFICATION_FLOW_LABELS: VerificationFlowLabels;

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

@@ -189,6 +189,124 @@
     decisionApproved: 'approved',
     decisionRejected: 'rejected',
     decisionPending: 'pending',
+    authoredTitle: 'Approval chain',
+    authoredSubtitle: 'The steps below run in order. Each one says who is asked, what closes it, and where each answer sends the record.',
+    addStep: 'Add step',
+    addStepFirst: 'Add the first step',
+    authoredEmptyTitle: 'No steps yet',
+    authoredEmptyBody: 'An approval chain is a list of steps. Add one, say who is asked to decide it, and the record will go to them in that order.',
+    stepNumber: (order)=>`Step ${order}`,
+    stepNamePlaceholder: (order)=>`Name this step (e.g. Quality review) — step ${order}`,
+    stepDescriptionPlaceholder: 'What the person deciding this step should check (optional)',
+    moveStepUp: 'Move earlier',
+    moveStepDown: 'Move later',
+    removeStep: 'Remove this step',
+    removeStepConfirm: (name)=>`Remove ${name}? Anything attached to it is removed with it.`,
+    stepKind: 'Kind',
+    stepKindApproval: 'Approval',
+    stepKindApprovalHint: 'Somebody is asked to approve or reject the record.',
+    stepKindRevision: 'Revision',
+    stepKindRevisionHint: 'Where a rejected record goes to be corrected. Send a rejection here from a later step.',
+    assignees: 'Who decides',
+    assigneesEmpty: 'Nobody yet. A step with nobody assigned stops the chain there.',
+    addAssignee: 'Add someone',
+    removeAssignee: 'Remove',
+    assigneeTypeRole: 'A role',
+    assigneeTypeUser: 'A person',
+    assigneeTypeAuthor: 'Whoever wrote the record',
+    assigneeTypeAuthorHint: 'Resolved when the step opens, so it is whoever wrote the record being reviewed.',
+    pickRole: 'Choose a role',
+    pickUser: 'Choose a person',
+    roleQuorum: 'How many of them',
+    roleQuorumOne: 'Any one member',
+    roleQuorumOneHint: 'The first member of the role to decide closes this slot.',
+    roleQuorumAll: 'Every member',
+    roleQuorumAllHint: 'Every active member of the role must decide. Adding a member while a review is running adds a signature it waits for.',
+    requireSignatureHint: 'The person deciding must attach a signature file.',
+    approvalMode: 'What closes this step',
+    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.',
+    outcomes: 'Where each answer sends it',
+    onApproved: 'If approved',
+    onApprovedNext: 'Go to the next step',
+    onApprovedComplete: 'Finish — the record is approved',
+    onApprovedGoto: 'Skip ahead to…',
+    onRejected: 'If rejected',
+    onRejectedEnd: 'Finish — the record is rejected',
+    onRejectedGoto: 'Send it back to…',
+    outcomeTargetPlaceholder: 'Choose a step',
+    stepOption: (order, name)=>name ? `${order}. ${name}` : `Step ${order}`,
+    noEarlierStep: 'There is no earlier step to send it back to.',
+    noLaterStep: 'There is no later step to skip to.',
+    maxPasses: 'Rounds allowed',
+    maxPassesHint: 'How many times a rejection may send the record back before the chain gives up and closes it rejected.',
+    maxPassesValue: (n)=>`${n} round${n === 1 ? '' : 's'}`,
+    actions: 'What happens',
+    flowActions: 'When the whole review starts or ends',
+    flowActionsHint: 'These belong to the review itself, not to any one step.',
+    stepActions: 'When this step happens',
+    addAction: 'Add something that happens',
+    removeAction: 'Remove',
+    actionsEmpty: 'Nothing happens automatically here.',
+    actionTrigger: 'When',
+    actionRecipients: 'Tell',
+    actionRecipientsEmpty: 'Nobody — this will send nothing.',
+    addRecipient: 'Add someone to tell',
+    actionChannels: 'How',
+    actionEnabled: 'On',
+    actionDisabled: 'Off',
+    actionFiresOnPass: 'Which rounds',
+    actionFiresEvery: 'Every round',
+    actionFiresFirst: 'Only the first round',
+    actionFiresRepeat: 'Only after the first round',
+    actionTitleTemplate: 'Title',
+    actionBodyTemplate: 'Message',
+    actionWindow: 'Only between',
+    actionStartsAt: 'From',
+    actionExpiresAt: 'Until',
+    actionTemplateHint: 'Use {{flow_name}}, {{step_name}}, {{step_order}}, {{pass_no}}, {{decision}} and {{reason}}. Double braces — single ones are sent exactly as typed.',
+    notifyTriggerFlowRejected: 'The whole review ended rejected',
+    notifyTriggerResubmitted: 'The author sent it back for review',
+    readinessTitle: 'Will this work?',
+    readinessChecking: 'Checking against the people on this install…',
+    readinessOk: 'Every step can be decided by somebody.',
+    readinessBlocked: (count)=>`${count} thing${count === 1 ? '' : 's'} would stop a real submission.`,
+    readinessWarnings: (count)=>`${count} thing${count === 1 ? '' : 's'} worth a look.`,
+    readinessRecheck: 'Check again',
+    readinessStepNeeds: (decisions, people)=>`${decisions} decision${decisions === 1 ? '' : 's'} · ${people} ${people === 1 ? 'person' : 'people'} available`,
+    readinessChainNeeds: (needed, available)=>`This chain needs ${needed} different ${needed === 1 ? 'person' : 'people'}; ${available} ${available === 1 ? 'account' : 'accounts'} can fill its steps.`,
+    readinessSlotPeople: (count)=>`${count} available`,
+    readinessSlotDeferred: 'decided when a record arrives',
+    readinessSaveRefusal: 'This cannot be saved yet',
+    readinessManageRoles: 'Manage roles and people',
+    editNoteRejectTargetCleared: (stepName)=>`${stepName} no longer sends a rejection anywhere — the step it pointed at is not before it any more. Choose where it should go.`,
+    editNoteApproveTargetCleared: (stepName)=>`${stepName} no longer skips ahead — the step it pointed at is not after it any more.`,
+    editNoteLastStepCompletes: (stepName)=>`${stepName} is now the last step, so it finishes the chain.`,
+    editNoteCompletionHandedOver: (stepName)=>`${stepName} no longer finishes the chain; the chain continues past it.`,
+    editNoteActionsDropped: (count)=>`${count} thing${count === 1 ? '' : 's'} attached to the removed step ${count === 1 ? 'was' : 'were'} removed with it.`,
+    editNotesDismiss: 'Got it',
+    diagramTitle: 'The chain',
+    diagramHint: 'Generated from the steps above. Read-only.',
+    diagramShow: 'Show the chain',
+    diagramHide: 'Hide the chain',
+    assigneeTypeLabel: 'Ask',
+    assigneeSlot: (index)=>`Person ${index}`,
+    approvalModeNoEffectHint: 'With one person listed these two do the same thing. It starts to matter as soon as a second is added.',
+    removeRecipient: 'Stop telling this one',
+    actionTitleRemaining: (remaining)=>`${remaining} characters left`,
+    actionFiresOnPassHint: 'A rejection can send the record back for another round. This says which of those rounds this one happens in.',
+    readinessUnclear: 'This could not be checked just now.',
+    readinessBlockingLabel: 'Would stop it',
+    readinessWarningLabel: 'Worth a look',
+    readinessBlockedAndWarned: (blocking, warnings)=>`${blocking} thing${blocking === 1 ? '' : 's'} would stop a real submission, and ${warnings} more ${warnings === 1 ? 'is' : 'are'} worth a look.`,
+    diagramNobodyDecides: 'nobody assigned',
+    diagramAssigneeCount: (count)=>`${count} asked`,
+    diagramSkipsTo: (stepLabel)=>`then skips ahead to ${stepLabel}`,
+    diagramSendsBackTo: (stepLabel)=>`if rejected, goes back to ${stepLabel}`,
+    diagramFinishesApproved: 'then the record is approved',
+    diagramFinishesRejected: 'if rejected, the record is rejected and the review ends',
     locale: 'en-US'
 };
 // ─── Enum → label maps ────────────────────────────────────────────
@@ -204,7 +322,14 @@ export function notificationTriggerLabels(say) {
         on_step_reached: say.notifyTriggerStepReached,
         on_approved: say.notifyTriggerApproved,
         on_rejected: say.notifyTriggerRejected,
-        on_flow_completed: say.notifyTriggerFlowCompleted
+        on_flow_completed: say.notifyTriggerFlowCompleted,
+        /*
+     * The two model 1 never had. `on_flow_completed` fires only on the
+     * approving path, so "reddedildi, haber ver" had no home anywhere in the
+     * product, and nobody could be told the author had sent a rejected record
+     * back.
+     */ on_flow_rejected: say.notifyTriggerFlowRejected,
+        on_resubmitted: say.notifyTriggerResubmitted
     };
 }
 export function notificationChannelLabels(say) {