@qoretechnologies/reqraft 0.10.57 → 0.10.58-pr.129.g2af0cf5

package/src/components/form/engine/FormEngine.stories.tsx

@@ -2153,6 +2153,114 @@ export const CompactWithholdsFieldsWithUnmetDependencies: Story = {
   },
 };
 
+/** A check whose kind decides which of the rest apply — the guided check's shape. */
+const lockedRequiredCheckOptions = {
+  kind: {
+    type: 'string',
+    ui_type: 'string',
+    display_name: 'Kind',
+    short_desc: 'What the check compares',
+    preselected: true,
+    allowed_values: [
+      { value: { type: 'string', value: 'equals' }, display_name: 'Equals' },
+      { value: { type: 'string', value: 'between' }, display_name: 'Between' },
+      { value: { type: 'string', value: 'exists' }, display_name: 'Exists' },
+    ],
+  },
+  expected: {
+    type: 'string',
+    ui_type: 'string',
+    display_name: 'Expected value',
+    short_desc: 'Applies once a kind is picked',
+    required: true,
+    depends_on: ['kind'],
+  },
+  min: {
+    type: 'int',
+    ui_type: 'int',
+    display_name: 'Minimum',
+    short_desc: 'Applies to Between alone',
+    required: true,
+    depends_on: ['kind=between'],
+  },
+  max: {
+    type: 'int',
+    ui_type: 'int',
+    display_name: 'Maximum',
+    short_desc: 'Applies to Between alone',
+    required: true,
+    depends_on: ['kind=between'],
+  },
+} as IOptionsSchema;
+
+export const CompactLockedRequiredNeedsNoAttention: Story = {
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'Renders a check whose Expected value, Minimum and Maximum are required but locked until a kind is picked. A locked field is not listed under "Needs attention": the author can do nothing with it yet. Each stays on the form, locked, among the optional fields, saying what unlocks it. With no kind picked, nothing needs attention and the header reads Ready: the locked fields do not apply yet.',
+      },
+    },
+  },
+  args: {
+    compact: true,
+    minColumnWidth: '300px',
+    options: lockedRequiredCheckOptions,
+    value: {} as IOptions,
+  },
+  play: async () => {
+    await _testsWaitForText('Expected value');
+    await waitFor(
+      () =>
+        expect(
+          document.querySelector(
+            '.readfirst-row[data-field="expected"] .options-readfirst-lock-deps'
+          )
+        ).toBeTruthy(),
+      { timeout: 10000 }
+    );
+    await expect(document.querySelector('[data-field="min"]')).toBeTruthy();
+    await expect(document.querySelector('[data-field="max"]')).toBeTruthy();
+    await _testsWaitForTextToNotExist('Needs attention');
+    // Nothing the author can fill in is missing, so the form is Ready — the
+    // locked fields do not apply until a kind is picked.
+    await _testsWaitForText('Ready');
+    await _testsWaitForTextToNotExist('Incomplete');
+  },
+};
+
+export const CompactUnlockedRequiredNeedsAttention: Story = {
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'Renders the same check with the kind set to Between. Every field that kind unlocks is required and empty, so Expected value, Minimum and Maximum are all listed under "Needs attention" and the header reads Incomplete (never Draft: nothing has been changed).',
+      },
+    },
+  },
+  args: {
+    compact: true,
+    minColumnWidth: '300px',
+    options: lockedRequiredCheckOptions,
+    value: { kind: { type: 'string', value: 'between' } } as IOptions,
+  },
+  play: async () => {
+    await _testsWaitForText('Needs attention');
+    await _testsWaitForText('Incomplete');
+    await _testsWaitForTextToNotExist('Draft');
+    const attention = [...document.querySelectorAll('.options-readfirst-group')].find((group) =>
+      (group.textContent || '').startsWith('Needs attention')
+    );
+    await expect(attention).toBeTruthy();
+    for (const field of ['expected', 'min', 'max']) {
+      await waitFor(
+        () => expect(attention!.querySelector(`[data-field="${field}"]`)).toBeTruthy(),
+        { timeout: 10000 }
+      );
+    }
+  },
+};
+
 export const CompactConditionalMessage: Story = {
   parameters: {
     docs: {
@@ -2616,6 +2724,63 @@ const _expandOptionalBox = async () => {
   }
 };
 
+/**
+ * Put one row of the Optional box on screen: open the box, and its "N more
+ * optional fields" fold if the row is behind it. A required field locked by an
+ * unmet dependency waits here rather than under "Needs attention", and a box
+ * that shows its preselected rows folds the rest.
+ */
+const _revealOptionalRow = async (field: string): Promise<{ refold: () => Promise<void> }> => {
+  await _expandOptionalBox();
+  const row = () => document.querySelector(`.readfirst-row[data-field="${field}"]`);
+  const opensFold = !row();
+  if (opensFold) {
+    await _testsClickButton({ selector: '.options-readfirst-more' });
+  }
+  await waitFor(() => expect(row()).toBeTruthy(), { timeout: 10000 });
+  return {
+    /** Close the fold again if this opened it, so the form is laid out as before. */
+    refold: async () => {
+      if (opensFold) {
+        await fireEvent.click(document.querySelector('.options-readfirst-more') as HTMLElement);
+        await waitFor(() => expect(row()).toBeNull(), { timeout: 10000 });
+      }
+    },
+  };
+};
+
+/** Every scrolled element in the page, with its scroll offsets. */
+const _scrollPositions = () =>
+  new Map(
+    [document.scrollingElement, ...Array.from(document.querySelectorAll('*'))]
+      .filter((element): element is Element => !!element)
+      .map((element) => [element, [element.scrollTop, element.scrollLeft] as const])
+  );
+
+/**
+ * Run `check` and leave the page scrolled exactly as it was. Opening a box or a
+ * fold to reach a row moves focus and scrolls the frame, and a story whose
+ * snapshot is its reference frame must not end somewhere else.
+ */
+const _withoutScrolling = async (check: () => Promise<void>) => {
+  const before = _scrollPositions();
+  await check();
+  const elements = [document.scrollingElement, ...Array.from(document.querySelectorAll('*'))];
+  for (const element of elements) {
+    if (!element) {
+      continue;
+    }
+    const [top, left] = before.get(element) ?? [0, 0];
+    if (element.scrollTop !== top || element.scrollLeft !== left) {
+      element.scrollTop = top;
+      element.scrollLeft = left;
+    }
+  }
+  (document.activeElement as HTMLElement | null)?.blur?.();
+  const top = before.get(document.scrollingElement as Element)?.[0] ?? 0;
+  await waitFor(() => expect(document.scrollingElement?.scrollTop ?? 0).toBe(top));
+};
+
 // CompactSchema plus one optional (non-preselected) field, to exercise the
 // "Fields" menu add / select-all / reset actions.
 const CompactFieldsMenuSchema: Record<string, TCompactField> = {
@@ -2785,9 +2950,10 @@ export const CompactReadOnly: Story = {
   },
   play: async () => {
     await _testsWaitForText('order-fulfilment');
-    // Nothing that reports progress: no meter, no Draft/Ready, no boxes.
+    // Nothing that reports progress: no meter, no Incomplete/Ready, no boxes.
     expect(document.querySelector('.options-readfirst-completion')).toBeNull();
     expect(document.querySelector('.options-readfirst-group')).toBeNull();
+    await _testsWaitForTextToNotExist('Incomplete');
     await _testsWaitForTextToNotExist('Draft');
     await _testsWaitForTextToNotExist('Needs attention');
     await _testsWaitForTextToNotExist('Optional');
@@ -2924,9 +3090,10 @@ export const CompactBasic: Story = {
     value: basicFormValue,
   },
   play: async () => {
-    // Unresolved required/invalid fields → the header shows the Draft badge
-    // (the IDE restyled-hero convention).
-    await _testsWaitForText('Draft');
+    // Unresolved required/invalid fields → the header says Incomplete. Never
+    // "Draft": nobody has changed this form, and Draft means unsaved changes.
+    await _testsWaitForText('Incomplete');
+    await _testsWaitForTextToNotExist('Draft');
     // Several asserted/clicked fields (Disabled option, …) are empty optionals in
     // the collapsed Optional box — open it so they're on screen.
     await _expandOptionalBox();
@@ -2955,7 +3122,9 @@ export const CompactBasic: Story = {
     ).toBeFalsy();
 
     // Dependency locks are navigable: the lock's popover lists the blockers
-    // with their state; clicking one scrolls to + flashes it.
+    // with their state; clicking one scrolls to + flashes it. The locked row is
+    // required, but locked it needs no attention, so it waits in Optional.
+    const lockedRow = await _revealOptionalRow('optionWithShortDescription');
     const depLock = document.querySelector(
       '.readfirst-row[data-field="optionWithShortDescription"] .options-readfirst-lock-deps'
     ) as HTMLElement;
@@ -2984,6 +3153,10 @@ export const CompactBasic: Story = {
       { timeout: 10000 }
     );
     await fireEvent.click(depLock); // close the popover
+    // Fold the Optional box's extra rows back, so the rest of the play (and the
+    // captured frame) sees the form laid out as before; once unlocked, the row
+    // moves to Needs attention and is on screen again.
+    await lockedRow.refold();
 
     // Fulfilling the dependency UNLOCKS the dependent row and flashes it.
     await _testsClickText('basicOption');
@@ -3612,7 +3785,7 @@ export const CompactSensitive: Story = {
 };
 
 // `rules: ['valid_identifier']` flows from the schema into validation: a bad
-// identifier marks the form invalid (banner + Draft badge).
+// identifier marks the form invalid (banner + Incomplete status).
 export const CompactValidIdentifierRule: Story = {
   parameters: {
     docs: {
@@ -3641,7 +3814,7 @@ export const CompactValidIdentifierRule: Story = {
     await _testsWaitForText('1-bad-identifier');
     // The rules-driven validation marks the form as needing attention — the
     // dedicated "Needs attention" box (and the header link) signal it.
-    await _testsWaitForText('Draft');
+    await _testsWaitForText('Incomplete');
     await _testsWaitForText('Needs attention');
   },
 };
@@ -5801,12 +5974,12 @@ export const CompactRequiredGroups: Story = {
     value: {} as IOptions,
   },
   play: async () => {
-    // All three members show the required placeholder + the Draft badge. The two
+    // All three members show the required placeholder + the Incomplete status. The two
     // contiguous members (byHost/byFile in Connection) cluster into a rail, which
     // carries the grouping in place of a chip; only the lone member (byUrl in
     // General) keeps a "One of" chip — so exactly one chip, not three.
     await _testsWaitForTextsCount('—', undefined, 3);
-    await _testsWaitForText('Draft');
+    await _testsWaitForText('Incomplete');
     await _testsWaitForTextsCount('One of', undefined, 1);
 
     // The chip is a ReqoreDropdown listing the siblings; selecting one flashes
@@ -5861,7 +6034,7 @@ export const CompactRequiredGroups: Story = {
     await _testsClickButton({ selector: '.options-readfirst-done' });
     await _testsWaitForText('https://example.com');
 
-    // One fulfilled member satisfies the group → the badge flips to Ready and the
+    // One fulfilled member satisfies the group → the status flips to Ready and the
     // Once satisfied: the filled member keeps a "Covers" chip; the empty siblings
     // show their "Covered by 'By URL'" note INLINE (not a chip), and no "One of"
     // remains. So exactly one required-group chip stays (the coverer's).
@@ -6468,10 +6641,30 @@ export const CompactShowcase: Story = {
     await expect(document.querySelectorAll('.options-readfirst-info-panel').length).toBeGreaterThan(
       0
     );
-    // The unmet-dependency hint surfaces on the dependent field's row.
-    await _testsWaitForText(
-      'This field is disabled because some dependencies are not fulfilled: "basicOption"'
+    // The unmet-dependency hint surfaces on the dependent field's row — locked,
+    // so in the Optional box rather than under "Needs attention". Not under
+    // Needs attention is a DOM fact; reaching the row means opening the
+    // Optional box's fold, which scrolls, so the frame is put back afterwards:
+    // this story's snapshot is the form's top.
+    const attentionBox = Array.from(document.querySelectorAll('.options-readfirst-group')).find(
+      (group) => (group.textContent || '').startsWith('Needs attention')
     );
+    await expect(
+      attentionBox?.querySelector('[data-field="optionWithShortDescription"]')
+    ).toBeFalsy();
+    await _withoutScrolling(async () => {
+      const lockedRow = await _revealOptionalRow('optionWithShortDescription');
+      const optionalBox = Array.from(document.querySelectorAll('.options-readfirst-group')).find(
+        (group) => (group.textContent || '').startsWith('Optional')
+      );
+      await expect(
+        optionalBox?.querySelector('[data-field="optionWithShortDescription"]')
+      ).toBeTruthy();
+      await _testsWaitForText(
+        'This field is disabled because some dependencies are not fulfilled: "basicOption"'
+      );
+      await lockedRow.refold();
+    });
     // ONE info mechanism: no subtitle lines, no badge — just the panel + ⓘ.
     await expect(document.querySelectorAll('.options-readfirst-subtitle')).toHaveLength(0);
     await expect(document.querySelectorAll('.options-readfirst-info-badge')).toHaveLength(0);

package/src/components/form/engine/FormEngine.tsx

@@ -76,7 +76,6 @@ import {
   ITemplateFieldProps,
   TCustomTemplateItems,
   TemplateField,
-  isValueTemplate,
 } from '../fields/template/TemplateField';
 import { CompactRow } from './CompactRow';
 import { FormFieldsSkeleton } from './FormFieldsSkeleton';
@@ -115,7 +114,6 @@ import { OptionsHelpDialog } from './OptionsHelpDialog';
 import { firstDeclaredType, isUntypedOptionType } from '../../../helpers/optionUiTypes';
 import {
   TReadFirstStatus,
-  findAllowedValueOption,
   getFirstAttentionOptionName,
   getOptionGroup,
   getOptionGroupLabel,
@@ -522,24 +520,15 @@ export const fixOptions = (
         (fixedValue[name] as IQorusFormField)?.value === undefined
       ) {
         obj = option.default_value as IQorusFormField;
-      } else if (
-        option.default_view === 'expression' &&
-        (fixedValue[name] as IQorusFormField)?.value === undefined
-      ) {
-        // A field the schema declares as opening in expression mode starts as an
-        // EMPTY expression, not as its raw default. `isDefaultFunction` already
-        // makes the renderer open that way, so without this the data disagreed
-        // with what the operator was looking at: an expression editor whose
-        // value was still the plain default, and no `is_expression` on the field
-        // until the first edit.
-        obj = {
-          type,
-          value: {
-            args: [],
-          },
-          is_expression: true,
-        };
       } else {
+        // A field declared with `default_view: 'expression'` is NOT seeded with
+        // an empty expression here. This runs on every load, so a seed written
+        // here changed a saved object merely by opening it: an existing Qog
+        // state gained `{args: []}` the moment its panel opened, and the editor
+        // autosaved a draft nobody made. The renderer already opens such a
+        // field in expression mode from the schema (`isDefaultFunction`), the
+        // first edit stores `is_expression`, and a host that creates a NEW
+        // object seeds the expression itself, at creation.
         obj = {
           type,
           value:
@@ -596,34 +585,15 @@ export const fixOptions = (
         };
       }
 
-      // A value that is not one of the declared choices is dropped. What counts
-      // as "one of the choices" is `findAllowedValueOption` — the same predicate
-      // the read-first row uses to LABEL a value — because a value the row can
-      // name is by definition a value the form must keep. Inlining a narrower
-      // test here (envelope and `name`, but not a bare `value`) silently erased
-      // every value declared the bare way: the collapsed row still showed its
-      // display name while the editor showed "—" and the value never reached
-      // the submitted data.
-      // `allowed_values: []` is NOT "no value is permitted" — it is the server
-      // saying it has no reference values to offer right now (the app-action
-      // catalogue ships exactly that, with an
-      // `option_reference_values_unavailable` message attached). An empty array
-      // is truthy, so testing the array itself made every such option erase the
-      // operator's stored value on the first render, before the
-      // connection-refreshed schema arrived to say otherwise — and the emptied
-      // form then autosaved over the draft, so the value was gone for good.
-      // Only an option that actually declares choices can have a value that is
-      // not one of them.
-      if (
-        newOption.value !== undefined &&
-        options?.[optionName]?.allowed_values?.length &&
-        !findAllowedValueOption(newOption.value, options?.[optionName]) &&
-        !isValueTemplate(newOption.value) &&
-        !options?.[optionName]?.multiselect &&
-        !options?.[optionName]?.allowed_values_creatable
-      ) {
-        newOption.value = undefined;
-      }
+      // A value that is not one of the declared choices is KEPT. It used to be
+      // dropped here, on load, and the dropped value was three times a real
+      // one — a bare-declared choice, a document naming a choice, a value whose
+      // choices had not arrived yet — that the emptied form then autosaved, so
+      // it was gone for good. Whether a value is one of the choices is now the
+      // validator's question (`getUnlistedChoiceReason`, asked through
+      // `validateFieldWithResult`): such a field is invalid, sits under "Needs
+      // attention" saying which value is not a choice, and the form reports
+      // itself invalid so the host blocks submitting it.
 
       if (
         newOption.value &&
@@ -1869,8 +1839,13 @@ const FormEngineImpl = ({
           ) ?
             schemaType
           : schemaType || ((fields[optionName] as IQorusFormField)?.type as TQorusType);
+        // A field reports back the type it was drawn as, which for a renderer-only editor (markdown, cron,
+        // dpql, ...) is the editor's name rather than the type the value is stored as. Storing that name
+        // sent a description as `{type: "markdown"}`, which the server decodes by type and so parsed as
+        // YAML. A type picked for an untyped field is never renderer-only, so it still wins.
+        const emittedType = _type && !isRendererOnly(_type as TQorusType) ? _type : undefined;
         const type =
-          _type ||
+          emittedType ||
           getTypeAndCanBeNull(resolvedSchemaType, options?.[optionName]?.allowed_values).type;
 
         if (!(fields as TQorusForm)[optionName]) {
@@ -1969,7 +1944,15 @@ const FormEngineImpl = ({
 
         onSingleOptionsChange?.(optionName, updatedValue[optionName]);
 
-        if (compact && !readOnly && shouldAutoCollapseCompactOption(options?.[optionName], val)) {
+        if (
+          compact &&
+          !readOnly &&
+          shouldAutoCollapseCompactOption(
+            options?.[optionName],
+            val,
+            !!(updatedValue[optionName] as { is_expression?: boolean } | undefined)?.is_expression
+          )
+        ) {
           setExpandedOptions((prev) => prev.filter((name) => name !== optionName));
         }
 
@@ -2324,10 +2307,13 @@ const FormEngineImpl = ({
 
   const isOptionValid = useCallback(
     (optionName: string, type: TQorusType, optionValue: any) => {
+      const isEmpty = optionValue === undefined || optionValue === '';
+      // An empty field locked by an unmet `depends_on` does not apply, so it is
+      // not missing — the same rule the read-first status follows.
       if (
-        !options?.[optionName]?.required &&
-        !options?.[optionName]?.required_groups &&
-        (optionValue === undefined || optionValue === '')
+        isEmpty &&
+        ((!options?.[optionName]?.required && !options?.[optionName]?.required_groups) ||
+          dependencyLockedNames.includes(optionName))
       ) {
         return true;
       }
@@ -2342,7 +2328,12 @@ const FormEngineImpl = ({
         isFunction: (availableOptions?.[optionName] as { is_expression?: boolean })?.is_expression,
       } as any);
     },
-    [JSON.stringify(options), JSON.stringify(availableOptions), JSON.stringify(localValue.fields)]
+    [
+      JSON.stringify(options),
+      JSON.stringify(availableOptions),
+      JSON.stringify(localValue.fields),
+      dependencyLockedNames,
+    ]
   );
 
   const getValidityData = useCallback((): IFormValidityData => {
@@ -2366,7 +2357,17 @@ const FormEngineImpl = ({
 
         let validation: IValidationResult;
 
-        if (!isRequired && !hasRequiredGroups && isEmpty) {
+        /* A required field locked by an unmet `depends_on` does not apply
+           while it is locked: it is not in "Needs attention", and an empty one
+           does not make the form incomplete either. Otherwise a check whose
+           kind is Equals could never be saved, because Minimum — required for
+           Between alone — is empty; and a form whose only gaps are fields
+           nobody can fill in would say Incomplete with nothing to act on. A
+           locked field that still HOLDS a value is validated as before. */
+        if (
+          isEmpty &&
+          ((!isRequired && !hasRequiredGroups) || dependencyLockedNames.includes(optionName))
+        ) {
           validation = { isValid: true, reasons: [] };
         } else {
           validation = validateFieldWithResult(getType(type), optionValue, {
@@ -2404,6 +2405,7 @@ const FormEngineImpl = ({
     JSON.stringify(options),
     JSON.stringify(operators),
     JSON.stringify(localValue.fields),
+    dependencyLockedNames,
   ]);
 
   const validityData = useMemo(() => getValidityData(), [getValidityData]);
@@ -2487,7 +2489,14 @@ const FormEngineImpl = ({
       // sub-form it summarises said 0/3 set.
       const empty = isOptionValueEmpty(value) || isUnsetSchemaHash(value, schema);
       const reqGroups = (schema?.required_groups as string[] | undefined) || [];
-      const required = !!(schema?.required || reqGroups.length);
+      // Required only while it applies. A field locked by an unmet `depends_on`
+      // renders disabled with what unlocks it; nothing the author can do to it
+      // is a next step — the next step is the field it depends on, which carries
+      // its own status. Counting it here put a guided check's locked Path /
+      // Minimum / Maximum under "Needs attention" before its kind was even
+      // picked. The moment the dependency holds, it is required again.
+      const required =
+        !dependencyLockedNames.includes(name) && !!(schema?.required || reqGroups.length);
       const covered =
         empty &&
         reqGroups.some((g) => {
@@ -2512,11 +2521,15 @@ const FormEngineImpl = ({
       isOptionValid,
       requiredGroupsInfo,
       schemaMsgIntent,
+      dependencyLockedNames,
     ]
   );
   const getOptionBucket = useCallback(
     (name: string, hidden = false): 'attention' | 'set' | 'optional' => {
-      if (!hidden) {
+      // A locked one-of member cannot be the one that satisfies its group, so it
+      // does not travel with the group into "Needs attention"; its own status
+      // (not required while locked) decides its box.
+      if (!hidden && !dependencyLockedNames.includes(name)) {
         const reqGroups = (options?.[name]?.required_groups as string[] | undefined) || [];
         if (reqGroups.length) {
           return reqGroups.some((g) => !requiredGroupsInfo.satisfiedBy[g]) ? 'attention' : 'set';
@@ -2524,7 +2537,7 @@ const FormEngineImpl = ({
       }
       return getReadFirstBucket(getOptionStatus(name, hidden));
     },
-    [JSON.stringify(options), requiredGroupsInfo, getOptionStatus]
+    [JSON.stringify(options), requiredGroupsInfo, getOptionStatus, dependencyLockedNames]
   );
   // How many fields are in the "Needs attention" box — drives the header link.
   const readFirstAttentionCount = useMemo(

package/src/components/form/engine/OptionFieldMessages.tsx

@@ -358,6 +358,9 @@ export const getOptionFieldMessages = ({
 }: IOptionFieldMessagesProps): IReqoreTagProps[] => {
   const optionSchema = schema[name];
   const result: IReqoreTagProps[] = [];
+  const locked =
+    !!optionSchema?.depends_on &&
+    !hasAllDependenciesFullfilled(optionSchema.depends_on, allOptions, schema);
 
   if (option.value || option.value === false || option.value === 0 || option.value === null) {
     /* A concrete type the VALUE carries beats an untyped schema.
@@ -392,7 +395,9 @@ export const getOptionFieldMessages = ({
       });
     }
   } else {
-    if (optionSchema?.required && !untouched) {
+    // A locked field is not asked for: the dependency message below says what
+    // unlocks it, and until then there is nothing to fill in.
+    if (optionSchema?.required && !untouched && !locked) {
       result.push({ label: 'This field is required', intent: 'danger' });
     }
 
@@ -413,10 +418,7 @@ export const getOptionFieldMessages = ({
     }
   }
 
-  if (
-    optionSchema?.depends_on &&
-    !hasAllDependenciesFullfilled(optionSchema.depends_on, allOptions, schema)
-  ) {
+  if (locked) {
     const dependsOn = describeDependencies(optionSchema.depends_on, schema);
 
     result.push({

package/src/components/form/engine/readFirst.ts

@@ -11,6 +11,7 @@ import { IExpressionValue } from '../expressions/types';
 import yaml from 'js-yaml';
 import { formatTimeoutValue, richtextToString } from '../../../helpers/common';
 import { firstDeclaredType } from '../../../helpers/optionUiTypes';
+import { findAllowedValueOption } from '../../../helpers/allowedValues';
 
 /** "N noun" with naive pluralisation ("1 item", "2 items"). */
 const pluralize = (count: number, noun: string): string =>
@@ -244,65 +245,33 @@ export const isCompactBooleanOption = (schema: TQorusFormFieldSchema | undefined
   return type === 'bool' || type === 'boolean';
 };
 
+/**
+ * Whether a change completes a compact row, so its editor can close.
+ *
+ * Only a VALUE does: Yes or No, or one of a fixed list. An expression is
+ * built one step at a time - an operation, then each of its arguments - and
+ * every step is a change; closing the editor on the first one left a bool
+ * field's condition at `null > null`, with no way to fill in its arguments
+ * short of opening the row again for each of them.
+ *
+ * @param isExpression the row now holds an expression (`is_expression`)
+ */
 export const shouldAutoCollapseCompactOption = (
   schema: TQorusFormFieldSchema | undefined,
-  value: unknown
+  value: unknown,
+  isExpression?: boolean
 ): boolean =>
+  !isExpression &&
   !isOptionValueEmpty(value) &&
   (isCompactBooleanOption(schema) || isFixedCompactAllowedValueOption(schema));
 
 /**
  * Prefer the matching allowed_values entry's display_name (fallback `name`)
- * over the raw stored value.
- *
- * A LIST carries its options under `element_allowed_values` — they constrain
- * each element, not the list itself — so a multi-select that was missing here
- * printed what it stores rather than what you picked: `orders, batch` for
- * fields whose picker reads "Orders, Batch". The gap shows worst exactly where
- * allowed values earn their keep, since the stored form is often not readable
- * at all (a permission code, `PO_REQUIRE_TYPES`, an app-specific id).
- *
- * Exported (as `findAllowedValueOption`) because the form engine's value
- * validation has to answer the SAME question — "is this stored value one of the
- * declared choices?" — and answering it differently loses data. An
- * `allowed_values` entry is written three ways: an envelope (`{value: {type,
- * value}}`), a bare value (`{value: 'default'}`) or a named entry
- * (`{name: 'default'}`). This has always accepted all three; the engine's
- * clearing guard accepted only the first and the third, so a schema using the
- * bare form had its value ERASED on load while this function went on rendering
- * the display name for it — the row read "Default RBAC" collapsed and "—" when
- * opened, and the value was gone from the submitted data.
+ * over the raw stored value. The predicate lives in `helpers/allowedValues`,
+ * where the validator uses it too, so a value the row can name is exactly a
+ * value the form accepts.
  */
-export const findAllowedValueOption = (
-  value: unknown,
-  schema?: TQorusFormFieldSchema
-): any | undefined => {
-  const s = schema as
-    { allowed_values?: any[]; element_allowed_values?: any[]; items?: any[] } | undefined;
-  const options =
-    (s?.allowed_values?.length && s.allowed_values) ||
-    (s?.element_allowed_values?.length && s.element_allowed_values) ||
-    s?.items;
-  if (!options?.length) {
-    return undefined;
-  }
-  // A stored element can be the bare value or the typed `{type, value}`
-  // envelope the form engine round-trips; match either against either.
-  const stored =
-    value && typeof value === 'object' && 'value' in (value as Record<string, unknown>) ?
-      (value as Record<string, unknown>).value
-    : value;
-
-  return options.find(
-    (option) =>
-      option?.value?.value === value ||
-      option?.value === value ||
-      option?.name === value ||
-      option?.value?.value === stored ||
-      option?.value === stored ||
-      option?.name === stored
-  );
-};
+export { findAllowedValueOption };
 
 const getAllowedValueLabel = (
   value: unknown,

package/src/components/form/engine/variants/VariantCalmTable.tsx

@@ -112,7 +112,9 @@ const Meter = ({ form }: { form: TVariantForm }) => {
             color: (s.attention ? c.warning : c.success) as never,
           }}
         >
-          {s.attention ? 'Draft' : 'Ready'}
+          {/* What the form lacks, not whether it has unsaved changes:
+              "Draft" is the batched mode's per-row chip alone. */}
+          {s.attention ? 'Incomplete' : 'Ready'}
         </ReqoreP>
         <span>
           {s.set} of {s.total} set