@qoretechnologies/reqraft 0.10.53 → 0.10.54-pr.115.gaf0d7a7

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

@@ -0,0 +1,76 @@
+import { ReqoreControlGroup, ReqoreSkeleton } from '@qoretechnologies/reqore';
+
+export interface IFormFieldsSkeletonProps {
+  /** How many field rows to stand in for. */
+  rows?: number;
+  /**
+   * Fill the height of the slot instead of being as tall as its rows.
+   *
+   * For a wait that stands in for a WHOLE form. Sizing from the row count makes
+   * the placeholder a different height from the thing that replaces it, so the
+   * swap resizes the container and everything jumps — measured on the live IDE
+   * at 396px of skeleton in an 835px slot. Filling the slot keeps the geometry
+   * still across the swap.
+   *
+   * NOT the default: a wait that stands in for one field or a nested hash is
+   * meant to be the size of that field, and stretching it to fill a panel would
+   * be a bigger lie than the jump.
+   */
+  fill?: boolean;
+  className?: string;
+  /**
+   * Which wait this placeholder stands for, surfaced as `data-wait`.
+   *
+   * A form has seven independent reasons to be waiting and they all draw the
+   * same picture, so "the form is still a placeholder at 2039ms" says nothing
+   * about what to fix — measured on the live alert rule, three sections cleared
+   * in the same commit and neither of the two shared waits (`types`, 140ms;
+   * `templates`, 1500ms) explained it. Naming the reason in the DOM turns that
+   * from a guess into a reading.
+   */
+  reason?: string;
+}
+
+/**
+ * A form that has not arrived yet, drawn as the form it is about to be.
+ *
+ * ONE shape for every wait inside a form, which is the whole point of it.
+ * Reported twice as "a series of skeletons": a single page could show the
+ * engine's own loading state (three bars over three big blocks), then a
+ * spinner reading "Loading field data…" while a field resolved its schema,
+ * then an 80px block for a nested hash, then the host's own field-row
+ * skeleton — four different pictures for one wait, each replacing the last, so
+ * a load that is actually quite quick reads as a stack of unrelated screens.
+ *
+ * A row is a label bar over an input bar because that is what a field is. The
+ * count is the only thing a caller varies: a nested field standing in for
+ * itself asks for one, a whole form for several.
+ */
+export const FormFieldsSkeleton = ({
+  rows = 6,
+  fill,
+  className,
+  reason,
+}: IFormFieldsSkeletonProps) => (
+  <ReqoreControlGroup
+    className={className}
+    data-wait={reason}
+    vertical
+    fluid
+    gapSize='big'
+    style={{
+      padding: '12px 6px',
+      width: '100%',
+      ...(fill ? { flex: '1 1 auto', minHeight: 0 } : {}),
+    }}
+  >
+    {Array.from({ length: rows }).map((_, index) => (
+      <ReqoreControlGroup key={index} vertical fluid gapSize='tiny'>
+        <ReqoreSkeleton size='small' width='140px' height='12px' />
+        <ReqoreSkeleton size='normal' width='100%' height='34px' />
+      </ReqoreControlGroup>
+    ))}
+  </ReqoreControlGroup>
+);
+
+export default FormFieldsSkeleton;

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

@@ -1,11 +1,13 @@
 import { ReqoreControlGroup, ReqoreTag, ReqoreVerticalSpacer } from '@qoretechnologies/reqore';
 import { IReqoreTagProps } from '@qoretechnologies/reqore/dist/components/Tag';
 import { IQorusFormField, IQorusFormSchema, TQorusForm } from '@qoretechnologies/ts-toolkit';
-import { flatten, size } from 'lodash';
+import { isArray, size } from 'lodash';
 import { useMemo } from 'react';
 import { getRequiredOptionMessage } from '../../../helpers/options';
+import { isUntypedOptionType } from '../../../helpers/optionUiTypes';
 import {
   hasAllDependenciesFullfilled,
+  parseDependency,
   validateFieldWithResult,
   validateOptionWithRequiredGroups,
 } from '../../../helpers/validations';
@@ -52,7 +54,10 @@ export const isConditionalMessageShown = (
   if (message.when && !hasAllDependenciesFullfilled(message.when as never, values, optionsSchema)) {
     return false;
   }
-  if (message.unless && hasAllDependenciesFullfilled(message.unless as never, values, optionsSchema)) {
+  if (
+    message.unless &&
+    hasAllDependenciesFullfilled(message.unless as never, values, optionsSchema)
+  ) {
     return false;
   }
   return true;
@@ -65,12 +70,82 @@ export const getShownSchemaMessages = <T extends IConditionalFieldMessage>(
   optionsSchema?: IQorusFormSchema
 ): T[] => (messages || []).filter((m) => isConditionalMessageShown(m, allOptions, optionsSchema));
 
+/**
+ * Name one `depends_on` entry so the reader can act on it.
+ *
+ * The list used to be built by looking each entry up as a whole field name,
+ * which is only ever true of the bare-name form. A COMPARISON entry
+ * (`kind=type`, `kind!=type`) matched no field, was dropped, and a field whose
+ * dependencies are all comparisons — the shape every subject field of a test
+ * uses — rendered "…are not fulfilled:" with nothing after the colon. The
+ * reader was told a dependency was unmet and not which one, by a sentence that
+ * stopped mid-way.
+ *
+ * One parser for both halves, the same one the evaluator uses, so the sentence
+ * and the lock cannot disagree about what an entry means.
+ */
+const describeDependency = (dependency: string, schema: IQorusFormSchema): string | undefined => {
+  const { name, op, value } = parseDependency(dependency);
+  const dependencySchema = schema[name];
+
+  if (!dependencySchema) {
+    return undefined;
+  }
+
+  const label = `"${dependencySchema.display_name || name}"`;
+
+  return op ? `${label} must ${op === '!=' ? 'not ' : ''}be "${value}"` : label;
+};
+
+/**
+ * The whole `depends_on` list as one phrase.
+ *
+ * A nested entry is an OR — only one of its members has to hold. It used to be
+ * flattened into the same comma-separated list as the top-level entries, which
+ * are an AND, so an either/or was shown to the reader as a set of things all
+ * required. The alternatives now stay grouped and joined by "or".
+ */
+const describeDependencies = (
+  dependencies: (string | string[])[] | string[][],
+  schema: IQorusFormSchema
+): string =>
+  (dependencies as (string | string[])[])
+    .map((entry) => {
+      if (!isArray(entry)) {
+        return describeDependency(entry as string, schema);
+      }
+      const alternatives = (entry as string[])
+        .map((dep) => describeDependency(dep, schema))
+        .filter((dep): dep is string => !!dep);
+      if (!alternatives.length) {
+        return undefined;
+      }
+      return alternatives.length > 1 ? `(${alternatives.join(' or ')})` : alternatives[0];
+    })
+    .filter((entry): entry is string => !!entry)
+    .join(', ');
+
 export interface IOptionFieldMessagesProps {
   schema: IQorusFormSchema;
   option: IQorusFormField;
   allOptions?: TQorusForm;
   name: string;
   getType: (type: string) => string;
+  /**
+   * The reader has not edited this field in this session.
+   *
+   * An error is a report that something went WRONG. "This field is required"
+   * under a field nobody has been in yet reports nothing: the form is empty
+   * because it is new. The requirement is already carried three other ways —
+   * the asterisk on the label, the Needs-attention box the row sits in, and the
+   * completion meter — so the message waits until the reader has been in the
+   * field and left it empty, which IS a thing that went wrong.
+   *
+   * Only the plain required message is held back. A value that fails
+   * validation, an unmet required GROUP and a locked dependency are all facts
+   * about what the form currently holds, and they show immediately.
+   */
+  untouched?: boolean;
 }
 
 /**
@@ -84,13 +159,26 @@ export const getOptionFieldMessages = ({
   name,
   allOptions,
   getType,
+  untouched,
 }: IOptionFieldMessagesProps): IReqoreTagProps[] => {
   const optionSchema = schema[name];
   const result: IReqoreTagProps[] = [];
 
   if (option.value || option.value === false || option.value === 0 || option.value === null) {
+    /* A concrete type the VALUE carries beats an untyped schema.
+       `auto`/`any` declare no type — the author picks one (Binary, Date, …)
+       and it is recorded beside the value. Reading the schema first validated
+       a binary value as `auto`, which auto-detects from the value and accepts
+       anything, so the form said the field needed attention while the field
+       itself gave no reason. The form's own check already prefers the stored
+       type (`getOptionFieldStorageType`); this is the same precedence. */
+    const schemaType = optionSchema?.ui_type as string;
+    const storedType = option.type as string;
+    const typeToValidate =
+      isUntypedOptionType(schemaType) && storedType ? storedType : schemaType || storedType;
+
     const validationData = validateFieldWithResult(
-      getType((optionSchema?.ui_type as string) || (option.type as string)),
+      getType(typeToValidate),
       option.value,
       {
         has_to_have_value: true,
@@ -109,7 +197,7 @@ export const getOptionFieldMessages = ({
       });
     }
   } else {
-    if (optionSchema?.required) {
+    if (optionSchema?.required && !untouched) {
       result.push({ label: 'This field is required', intent: 'danger' });
     }
 
@@ -134,14 +222,16 @@ export const getOptionFieldMessages = ({
     optionSchema?.depends_on &&
     !hasAllDependenciesFullfilled(optionSchema.depends_on, allOptions, schema)
   ) {
-    const dependsOn = flatten(optionSchema.depends_on)
-      .filter((dep: string) => !!schema[dep])
-      .map((dep: string) => schema[dep].display_name || dep)
-      .map((dep: string) => `"${dep}"`)
-      .join(', ');
+    const dependsOn = describeDependencies(optionSchema.depends_on, schema);
 
     result.push({
-      label: `This field is disabled because some dependencies are not fulfilled: ${dependsOn}`,
+      label:
+        dependsOn ?
+          `This field is disabled because some dependencies are not fulfilled: ${dependsOn}`
+          // Nothing nameable: every entry pointed at a field this schema does
+          // not contain. A sentence that ends in a colon and then stops reads
+          // as a rendering fault rather than as a fact about the form.
+        : 'This field is disabled because some dependencies are not fulfilled',
       intent: 'warning',
     });
   }
@@ -155,10 +245,11 @@ export const OptionFieldMessages = ({
   name,
   allOptions,
   getType,
+  untouched,
 }: IOptionFieldMessagesProps) => {
   const messages: IReqoreTagProps[] = useMemo(
-    () => getOptionFieldMessages({ schema, option, name, allOptions, getType }),
-    [JSON.stringify(schema), JSON.stringify(option), JSON.stringify(allOptions), name]
+    () => getOptionFieldMessages({ schema, option, name, allOptions, getType, untouched }),
+    [JSON.stringify(schema), JSON.stringify(option), JSON.stringify(allOptions), name, untouched]
   );
 
   if (!size(messages)) {

package/src/components/form/engine/_structuredData/SchemaDataView.tsx

@@ -24,6 +24,7 @@ import {
   fieldLabel,
   findAllowedValueOption,
   formatOptionValue,
+  getAllowedValueIcon,
   getAllowedValueImage,
   isCodeField,
   orderedKeys,
@@ -356,7 +357,11 @@ const FieldValue = ({
   const formatted = formatOptionValue(field, fieldSchema);
   // An allowed value that carries a logo shows it here too, exactly as the row
   // above does — the preview is the same value, so it gets the same treatment.
+  // An option marked with an ICON rather than a logo gets the same, for the same
+  // reason: the mark is how a list of bare words is told apart, and dropping it
+  // here would make the preview disagree with the row it previews.
   const image = getAllowedValueImage(field.value, fieldSchema);
+  const icon = getAllowedValueIcon(field.value, fieldSchema);
 
   // Data reads in mono; a chosen label does not.
   //
@@ -387,6 +392,12 @@ const FieldValue = ({
               size='14px'
               style={{ flexShrink: 0, marginRight: 6, verticalAlign: 'middle' }}
             />
+          : icon ?
+            <ReqoreIcon
+              icon={icon as any}
+              size='14px'
+              style={{ flexShrink: 0, marginRight: 6, verticalAlign: 'middle' }}
+            />
           : null}
           {isNavigableUrl(field.value) ?
             // The address IS the link — it used to render as inert text with a

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

@@ -35,7 +35,7 @@ export interface ICompactToolbarContext {
   // Completion meter
   invalidCount: number;
   attentionCount: number;
-  completion: { set: number; total: number; pct: number };
+  completion: { set: number; done: number; total: number; pct: number };
   // Invalid-fields banner (pinned in the sticky header)
   showInvalidOnly: boolean;
   onToggleInvalidOnly: () => void;

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

@@ -316,6 +316,31 @@ export const getAllowedValueImage = (
   return (match?.image as string) || undefined;
 };
 
+/**
+ * The selected option's ICON, when it carries one and no logo — for the value
+ * cell.
+ *
+ * The same idea as {@link getAllowedValueImage} and read for the same reason:
+ * an option's mark belongs beside the value it names. Only images were rendered,
+ * so a picker whose entries are distinguished by ICON — an interface-kind list
+ * where every entry is a bare word, `Service`, `Job`, `Qog` — showed each mark
+ * while choosing and then dropped it the moment the row went read-only, which is
+ * the surface a reader spends the most time on.
+ *
+ * The image wins where an option has both: a logo is the more specific mark, and
+ * an icon standing behind it is a fallback rather than a second thing to draw.
+ */
+export const getAllowedValueIcon = (
+  value: unknown,
+  schema?: TQorusFormFieldSchema
+): string | undefined => {
+  const match = findAllowedOption(value, schema);
+  if (!match || match.image) {
+    return undefined;
+  }
+  return (match.icon as string) || undefined;
+};
+
 /** Clamp an RGB channel to a 0–255 integer. */
 const clampChannel = (n: number): number => Math.max(0, Math.min(255, Math.round(n)));
 const toHexPart = (n: number): string => clampChannel(n).toString(16).padStart(2, '0');
@@ -556,6 +581,36 @@ export const summariseMarkdown = (value: unknown): string => {
   return capSummary(prose);
 };
 
+/**
+ * The expression AST a field holds, whichever shape it arrived in.
+ *
+ * An expression arrives in TWO shapes, and only the flat one used to be
+ * checked. At runtime the editor writes the flag onto the option
+ * (`{ is_expression: true, value: ast }`); a value read back from a saved draft
+ * carries the envelope NESTED (`{ value: { is_expression: true, value: ast } }`)
+ * with no flag on the option at all. Missing the nested shape sent a reloaded
+ * expression to the generic formatter, which printed the AST — the row showed
+ * `is_expression true / value / exp + / args 1 2` where the expression should
+ * be.
+ *
+ * Exported because the SUMMARY is not the only place that has to know. The AST
+ * is how an expression is stored, not what it is, so nothing may draw it as
+ * data: `CompactRow` asks this before deciding a hash-shaped value has earned a
+ * structured inset. Answering it in one place is what keeps the row's two
+ * halves — the line and the inset under it — talking about the same value.
+ */
+export const getExpressionAst = (option?: {
+  is_expression?: boolean;
+  value?: unknown;
+}): IExpressionValue | undefined =>
+  option?.is_expression ? (option?.value as IExpressionValue | undefined)
+  : (
+    (option?.value as { is_expression?: boolean; value?: IExpressionValue } | undefined)
+      ?.is_expression
+  ) ?
+    (option?.value as { value?: IExpressionValue }).value
+  : undefined;
+
 export const formatOptionValue = (
   option?: IQorusFormField,
   schema?: TQorusFormFieldSchema
@@ -572,11 +627,13 @@ export const formatOptionValue = (
     return '••••••';
   }
 
-  if (option?.is_expression) {
+  const expressionAst = getExpressionAst(option);
+
+  if (expressionAst !== undefined) {
     // Offline summary of the {exp,args} AST already in the form value — the
     // same client-side renderer the editor's "Explain" seam falls back to when
     // the LSP is unreachable. The drill-in editor shows the canonical DPQL.
-    return renderExpressionToText(option?.value as IExpressionValue | undefined) || 'Expression';
+    return renderExpressionToText(expressionAst) || 'Expression';
   }
 
   // schema-definition is stored as a hash envelope; summarise it as the schema
@@ -792,7 +849,10 @@ export const getOptionGroupLabel = (
 /** Completion summary for the read-first progress meter. */
 export interface IReadFirstCompletion {
   total: number;
+  /** Fields holding a value, whether or not anything is wrong with it. */
   set: number;
+  /** Fields holding a value that nothing is flagging — what the meter fills. */
+  done: number;
   pct: number;
 }
 
@@ -831,14 +891,33 @@ export const getReadFirstBucket = (status: TReadFirstStatus): 'attention' | 'set
 
 /** Count how many of the shown options have a value set, for the progress meter. */
 export const getReadFirstCompletion = (
-  shownOptions: Record<string, IQorusFormField | undefined> = {}
+  shownOptions: Record<string, IQorusFormField | undefined> = {},
+  /**
+   * Whether the form flags this field as needing attention. Optional: without
+   * it the meter falls back to counting values alone, which is what a caller
+   * with no bucketing of its own can honestly say.
+   */
+  needsAttention?: (name: string) => boolean
 ): IReadFirstCompletion => {
   const names = Object.keys(shownOptions);
   const total = names.length;
-  const set = names.filter((name) => !isOptionValueEmpty(shownOptions[name]?.value)).length;
-  const pct = total ? Math.round((set / total) * 100) : 0;
-
-  return { total, set, pct };
+  const hasValue = (name: string) => !isOptionValueEmpty(shownOptions[name]?.value);
+  const set = names.filter(hasValue).length;
+  /* "Set" and "needs attention" are not opposites. A field can hold a value and
+     still be wrong — one that fails validation, or one the host has flagged
+     because something INSIDE it is unfinished — and counting those as progress
+     is how a form comes to report 100% while the box beneath it says a field
+     needs attention.
+
+     It also cost the meter its amber run: the bar draws attention from `set%`
+     onward, so a field counted in both pushed that run past the right edge,
+     where `overflow: hidden` swallowed it. The one visual signal that something
+     was outstanding was the one thing the double-count hid. */
+  const done =
+    needsAttention ? names.filter((name) => hasValue(name) && !needsAttention(name)).length : set;
+  const pct = total ? Math.round((done / total) * 100) : 0;
+
+  return { total, set, done, pct };
 };
 
 /** What the "first field to fix" selector needs to know about one field.

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

@@ -1,4 +1,16 @@
 import { TQorusType } from '@qoretechnologies/ts-toolkit';
+import { IReqoreFormTemplates } from '@qoretechnologies/reqore/dist/components/Textarea';
+
+/**
+ * A field schema that carries a template list of its own.
+ *
+ * `templates` is deliberately NOT added to `TQorusFormFieldSchema`: that type is
+ * owned by ts-toolkit and shared with consumers that have no notion of a form
+ * engine, so the capability is read through this narrow view instead of widening
+ * the shared type from here. A schema that sets it is offering a list scoped to
+ * one field rather than to the whole form.
+ */
+export type TFieldWithOwnTemplates = { templates?: IReqoreFormTemplates };
 
 /**
  * A schema entry carries two type-ish keys with different jobs:

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

@@ -0,0 +1,159 @@
+// Copyright 2026 Qore Technologies, s.r.o.
+import { IReqoreDropdownItem } from '@qoretechnologies/reqore/dist/components/Dropdown/list';
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+/**
+ * SEAM (reqraft): an editor publishes its own actions into the row's ⋮ menu.
+ *
+ * A row already renders one overflow menu — Edit fullscreen, Remove field, and
+ * any `optionActions` the host injected — and the comment on it has always said
+ * why: *"this row already has a menu, so they reuse it rather than adding a
+ * second one beside it."* An EDITOR could not reach that menu, so an editor
+ * with affordances of its own had no choice but to draw a second ⋮ inside the
+ * value cell. The IDE's template field does exactly that, and the two menus
+ * ended up side by side on one control, at slightly different widths.
+ *
+ * `optionActions` does not solve it: that seam is host configuration, resolved
+ * from the option's name and schema before the editor exists, so it cannot know
+ * what the editor can offer *now* — whether its templates have loaded, whether
+ * the value is already an expression, which custom items the field was given.
+ *
+ * ## Why registration is keyed, and by whom
+ *
+ * Menu items carry `onClick` handlers, so they are a new array on every render
+ * and cannot be compared by value. An editor therefore publishes a `key`
+ * alongside them: a primitive describing WHICH items it is currently offering
+ * (`'expression,template'`). The row re-renders only when a publisher's key
+ * changes, so a re-rendering editor cannot drive the row into a state loop.
+ *
+ * Each registration also belongs to ONE publisher. A single shared slot let
+ * two publishers in the same row — an expression builder's operands — overwrite
+ * each other's key on every render, which re-rendered the row and both of them,
+ * which published again: a synchronous render loop that froze the page. And a
+ * slot that outlived its editor kept that editor's handlers after it unmounted,
+ * so a row closed and reopened offered items that did nothing. Registrations
+ * are therefore per publisher, withdrawn on unmount, and a click always reaches
+ * the handler from the publisher's latest render.
+ *
+ * Publish with `useRowMenuPublisher`; provide with `useRowMenuRegistry`.
+ */
+export interface IRowMenuRegistration {
+  /**
+   * Publish a publisher's menu items into the containing row's ⋮.
+   *
+   * @param publisherId identifies the publishing editor (one per mounted editor)
+   * @param key a primitive describing which items are being offered; the row
+   * re-renders only when it changes
+   * @param items the items to merge, or an empty array to contribute none
+   */
+  registerRowMenuItems: (publisherId: string, key: string, items: IReqoreDropdownItem[]) => void;
+  /** Withdraw a publisher's items — when it unmounts or leaves the row. */
+  unregisterRowMenuItems: (publisherId: string) => void;
+}
+
+/**
+ * Absent outside a compact row — the classic (non-compact) render path has no
+ * row menu to merge into, and an editor there keeps drawing its own control.
+ */
+export const RowMenuContext = createContext<IRowMenuRegistration | undefined>(undefined);
+
+/**
+ * The row-menu channel for the row this editor is inside, or `undefined` when
+ * there is no row menu to publish into.
+ *
+ * An editor that finds it should render no menu of its own; one that does not
+ * must keep rendering its own, or its actions become unreachable.
+ */
+export const useRowMenu = (): IRowMenuRegistration | undefined => useContext(RowMenuContext);
+
+/**
+ * Publish `items` into `rowMenu` for as long as the calling editor is mounted.
+ * `rowMenu` is passed rather than read here so an editor can claim the channel
+ * and hide it from what it renders (see `TemplateField`).
+ */
+export const useRowMenuPublisher = (
+  rowMenu: IRowMenuRegistration | undefined,
+  key: string,
+  items: IReqoreDropdownItem[]
+): void => {
+  const publisherId = useId();
+
+  useEffect(() => {
+    rowMenu?.registerRowMenuItems(publisherId, key, items);
+  }, [rowMenu, publisherId, key, items]);
+
+  useEffect(() => () => rowMenu?.unregisterRowMenuItems(publisherId), [rowMenu, publisherId]);
+};
+
+/**
+ * The row side of the channel: the registration to provide, and the items the
+ * row's ⋮ should list.
+ */
+export const useRowMenuRegistry = (): {
+  rowMenu: IRowMenuRegistration;
+  items: IReqoreDropdownItem[];
+} => {
+  // Which publishers are offering which item SET — the only state, so only a
+  // change of set re-renders the row.
+  const [keys, setKeys] = useState<Record<string, string>>({});
+  // Each publisher's items from its latest render, read at click time.
+  const latest = useRef<Record<string, IReqoreDropdownItem[]>>({});
+
+  const registerRowMenuItems = useCallback(
+    (publisherId: string, key: string, items: IReqoreDropdownItem[]) => {
+      latest.current[publisherId] = items;
+      setKeys((previous) =>
+        previous[publisherId] === key ? previous : { ...previous, [publisherId]: key }
+      );
+    },
+    []
+  );
+
+  const unregisterRowMenuItems = useCallback((publisherId: string) => {
+    delete latest.current[publisherId];
+    setKeys((previous) => {
+      if (!(publisherId in previous)) {
+        return previous;
+      }
+      const next = { ...previous };
+      delete next[publisherId];
+      return next;
+    });
+  }, []);
+
+  const rowMenu = useMemo(
+    () => ({ registerRowMenuItems, unregisterRowMenuItems }),
+    [registerRowMenuItems, unregisterRowMenuItems]
+  );
+
+  const items = useMemo(
+    () =>
+      Object.keys(keys).flatMap((publisherId) =>
+        (latest.current[publisherId] ?? []).map((item, index) =>
+          item.onClick
+            ? {
+                ...item,
+                // Same key, same item set, so the index still names this item;
+                // the handler is whatever the publisher rendered last.
+                onClick: ((...args: unknown[]) =>
+                  (latest.current[publisherId]?.[index]?.onClick as
+                    | ((...clickArgs: unknown[]) => unknown)
+                    | undefined)?.(...args)) as IReqoreDropdownItem['onClick'],
+              }
+            : item
+        )
+      ),
+    [keys]
+  );
+
+  return { rowMenu, items };
+};

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

@@ -0,0 +1,61 @@
+// Copyright 2026 Qore Technologies, s.r.o.
+/**
+ * Which options offer the per-type choices ("Integer", "Text", "Hash", …) in
+ * the row's menu.
+ *
+ * A field that pins no concrete type has to give the author some way to say
+ * what kind of value they mean, and the row menu is where that lives — the
+ * alternative, a standalone *"Please select data type"* control, replaces a
+ * typable field with a pick-only one.
+ *
+ * The rule was `ui_type === 'any'`, which is one of the three ways a schema
+ * says "untyped", so the choices went missing on the other two:
+ *
+ *  - **`type: 'auto'` with no `ui_type` at all.** This is how the server
+ *    declares an assertion's Expected Value, so that field never offered them.
+ *    They appeared only inside an expression, where the OPERAND's schema does
+ *    say `ui_type: 'any'` — so the same option offered them in the Visual view
+ *    and not in the Text view, which reads as the menu losing items.
+ *  - **A host's own untyped editor.** The IDE renders Expected Value through
+ *    `test-reference`, a `ui_type` reqraft knows nothing about; the field is no
+ *    less untyped for having a custom editor.
+ *
+ * `ui_type` is asked FIRST and on its own: a schema that names a concrete
+ * editor (`ui_type: 'string'`) has pinned the field even if its storage `type`
+ * is still `auto`.
+ */
+import { IQorusFormField } from '@qoretechnologies/ts-toolkit';
+import { UNTYPED_OPTION_TYPES } from '../../../helpers/optionUiTypes';
+
+/**
+ * The spellings that mean "no concrete type" wherever they appear.
+ *
+ * Re-exported from the type vocabulary in `helpers/optionUiTypes`, which is
+ * where it now lives so non-component code can ask the same question.
+ */
+export const BuiltInAnyLikeTypes: readonly string[] = UNTYPED_OPTION_TYPES;
+
+/**
+ * Does this option leave its type up to the author?
+ *
+ * @param option the option's schema entry
+ * @param extraUiTypes host `ui_type` names that are untyped editors of their
+ * own — see `FormEngine`'s `anyLikeUiTypes`
+ */
+export const offersTypeChoices = (
+  option: Partial<IQorusFormField> | undefined,
+  extraUiTypes?: string[]
+): boolean => {
+  if (!option) {
+    return false;
+  }
+
+  const uiType = (option as { ui_type?: string }).ui_type;
+
+  if (uiType) {
+    return BuiltInAnyLikeTypes.includes(uiType) || !!extraUiTypes?.includes(uiType);
+  }
+
+  // No `ui_type`: the storage type is the only thing that can pin the field.
+  return BuiltInAnyLikeTypes.includes((option as { type?: string }).type as string);
+};