nucleus-core-ts 0.10.129 → 0.10.131

package/dist/.build-ok

@@ -1 +1 @@
-0.10.129
+0.10.131

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

@@ -281,6 +281,18 @@ export function PendingTab({ pendingAction, decideAction, uploadSignatureAction,
                                 store.decidingId === item.instance_id ? /*#__PURE__*/ _jsxs("div", {
                                     className: theme.pending.card.actions,
                                     children: [
+                                        typeof item.pass_no === 'number' && typeof item.max_passes === 'number' ? /*#__PURE__*/ _jsxs("p", {
+                                            className: theme.pending.card.decisionMeta,
+                                            children: [
+                                                item.max_passes > 1 ? say.pendingRound(item.pass_no, item.max_passes) : null,
+                                                item.max_passes > 1 ? ' · ' : null,
+                                                item.rejection_sends_back_to ? say.pendingRejectSendsBack(say.stepOption(item.rejection_sends_back_to.step_order, item.rejection_sends_back_to.step_name)) : say.pendingRejectEndsReview
+                                            ]
+                                        }) : null,
+                                        item.is_last_pass === true && (item.max_passes ?? 1) > 1 ? /*#__PURE__*/ _jsx("p", {
+                                            className: theme.pending.card.lastRoundWarning,
+                                            children: say.pendingLastRoundWarning
+                                        }) : null,
                                         item.require_signature ? /*#__PURE__*/ _jsxs("label", {
                                             className: "flex flex-col gap-1 text-xs",
                                             children: [

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

@@ -1,5 +1,5 @@
 import type { VerificationFlowLabels } from '../labels';
-import type { VerificationBulkStatusItem, VerificationCancelAction, VerificationEntityStatusesAction } from '../types';
+import type { VerificationBulkStatusItem, VerificationCancelAction, VerificationEntityStatusesAction, VerificationStartForEntityAction } from '../types';
 export type VerificationEntityListTheme = {
     container: string;
     header: string;
@@ -52,5 +52,17 @@ export type VerificationEntityListProps = {
      * now the API had one and the product offered none.
      */
     cancelAction?: VerificationCancelAction;
+    /**
+     * Puts a record back into review.
+     *
+     * It was declared on the page's props, passed in by the panel, and never
+     * destructured anywhere — so on a flow with `trigger_on: 'manual'` there was
+     * no way from the product to start a review at all. This list is the one
+     * screen that knows which chains have FINISHED, so a rejected record that has
+     * since been corrected gets its next review here. A record that has never
+     * been reviewed does not appear in this list (it is built from instances), so
+     * its first review still starts from the record's own screen.
+     */
+    startForEntityAction?: VerificationStartForEntityAction;
 };
-export declare function VerificationEntityList({ entityName, entityStatusesAction, theme: themeOverrides, themeMode, onEntityClick, pageSize, labels, cancelAction, }: VerificationEntityListProps): import("react/jsx-runtime").JSX.Element;
+export declare function VerificationEntityList({ entityName, entityStatusesAction, theme: themeOverrides, themeMode, onEntityClick, pageSize, labels, cancelAction, startForEntityAction, }: VerificationEntityListProps): import("react/jsx-runtime").JSX.Element;

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

@@ -97,7 +97,7 @@ const lightTheme = {
     };
     return map[status] ?? status;
 }
-export function VerificationEntityList({ entityName, entityStatusesAction, theme: themeOverrides, themeMode = 'dark', onEntityClick, pageSize = 20, labels, cancelAction }) {
+export function VerificationEntityList({ entityName, entityStatusesAction, theme: themeOverrides, themeMode = 'dark', onEntityClick, pageSize = 20, labels, cancelAction, startForEntityAction }) {
     const baseTheme = themeMode === 'light' ? lightTheme : darkTheme;
     const t = {
         ...baseTheme,
@@ -113,6 +113,50 @@ export function VerificationEntityList({ entityName, entityStatusesAction, theme
     const [cancellingId, setCancellingId] = useState(null);
     const [cancelReason, setCancelReason] = useState('');
     const [cancelNote, setCancelNote] = useState(null);
+    // Which row is being sent back into review, and what it was told.
+    const [startingId, setStartingId] = useState(null);
+    const [startNote, setStartNote] = useState(null);
+    const startAgain = useEffectEvent((item)=>{
+        if (!startForEntityAction) return;
+        setStartingId(item.instance_id);
+        setStartNote(null);
+        startForEntityAction.start({
+            payload: {
+                entity_name: item.entity_name,
+                entity_id: item.entity_id
+            },
+            onAfterHandle: (res)=>{
+                setStartingId(null);
+                const r = res;
+                /*
+         * The engine has plenty of legitimate reasons to refuse — no live flow
+         * for this entity, the first step resolves to nobody, a chain is
+         * already running — and each one is a sentence. Shown on the row rather
+         * than swallowed: a button that does nothing and says nothing is how
+         * "send to review does not work" became a support conversation.
+         */ if (r.success === false) {
+                    setStartNote({
+                        id: item.instance_id,
+                        text: r.message || say.startReviewFailed
+                    });
+                    return;
+                }
+                setStartNote({
+                    id: item.instance_id,
+                    text: r.message || say.reviewStartedNote
+                });
+                loadStatuses(activeTab === 'all' ? undefined : activeTab, currentPage);
+            },
+            onErrorHandle: (err)=>{
+                setStartingId(null);
+                const e = err;
+                setStartNote({
+                    id: item.instance_id,
+                    text: e?.message || say.startReviewFailed
+                });
+            }
+        });
+    });
     const loadStatuses = useEffectEvent((status, page)=>{
         entityStatusesAction.start({
             payload: {
@@ -332,6 +376,25 @@ export function VerificationEntityList({ entityName, entityStatusesAction, theme
                                 className: `${t.statusBadge} ${getStatusBadgeClass(item.status)}`,
                                 children: statusLabel(say, item.status)
                             }),
+                            startForEntityAction && item.status !== 'active' ? /*#__PURE__*/ _jsxs("div", {
+                                className: "shrink-0 flex flex-col items-end gap-1",
+                                children: [
+                                    /*#__PURE__*/ _jsx("button", {
+                                        type: "button",
+                                        disabled: startingId === item.instance_id,
+                                        onClick: (e)=>{
+                                            e.stopPropagation();
+                                            startAgain(item);
+                                        },
+                                        className: themeMode === 'light' ? 'rounded-lg border border-gray-200 bg-white px-2.5 py-1 text-[11px] font-medium text-gray-600 hover:bg-gray-100 disabled:opacity-50 disabled:cursor-not-allowed' : 'rounded-lg border border-white/[0.08] bg-white/[0.04] px-2.5 py-1 text-[11px] font-medium text-white/60 hover:bg-white/[0.1] disabled:opacity-40 disabled:cursor-not-allowed',
+                                        children: startingId === item.instance_id ? say.startingReview : say.startNewReview
+                                    }),
+                                    startNote?.id === item.instance_id ? /*#__PURE__*/ _jsx("p", {
+                                        className: themeMode === 'light' ? 'max-w-[18rem] text-right text-[10px] leading-relaxed text-gray-500' : 'max-w-[18rem] text-right text-[10px] leading-relaxed text-white/45',
+                                        children: startNote.text
+                                    }) : null
+                                ]
+                            }) : null,
                             cancelAction && item.status === 'active' ? cancellingId === item.instance_id ? // No handlers on this wrapper: the row above is a button
                             // when `onEntityClick` is set, so each INTERACTIVE child
                             // stops the bubble itself rather than a bare div doing it

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, startForEntityAction, 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, startForEntityAction, 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", {
@@ -1308,7 +1551,14 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
                     onEntityClick: onEntityClick,
                     themeMode: themeMode,
                     labels: say,
-                    cancelAction: cancelAction
+                    cancelAction: cancelAction,
+                    /*
+             * Declared on these props, passed in by the panel, and destructured
+             * NOWHERE until now — so on a flow with `trigger_on: 'manual'` the
+             * product had no way to put a record into review at all. The list
+             * knows which chains have finished, so a corrected record gets its
+             * next review from the row it is already on.
+             */ startForEntityAction: startForEntityAction
                 })
             })
         ]

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';