jsfe 1.40.0 → 1.40.2

package/dist/forms/form-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form-client.d.ts","sourceRoot":"","sources":["../../src/forms/form-client.js"],"names":[],"mappings":"AA2BA,iGAAiG;AACjG;;;;;SAmEC;AAED,+GAA+G;AAC/G;;;;SAgCC;AAED;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BC;AA9JD,qCAAsC,eAAe,CAAC"}
+{"version":3,"file":"form-client.d.ts","sourceRoot":"","sources":["../../src/forms/form-client.js"],"names":[],"mappings":"AA2BA,iGAAiG;AACjG;;;;;SA6EC;AAED,+GAA+G;AAC/G;;;;SAgCC;AAED;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BC;AAxKD,qCAAsC,eAAe,CAAC"}

package/dist/forms/form-client.js

@@ -40,12 +40,13 @@ export function projectForm(session, flows) {
     const { state: root, context } = pending, cargo = session.cargo, language = session.language || 'en';
     // Both the code field and its free-text fallback can contain the one-time code.
     const collectingOtp = session.flowStacks.flat().some(frame => frame.flowId === 'get-and-validate-otp-code');
+    let askedShown = false;
     const fields = (specs, state, prefix = '', depth = 0) => {
         if (depth > 16)
             return [];
         const out = [];
         for (const input of specs || []) {
-            if (!safe(input.name) || input.form_client === false || input.internal || input.bind || input.confirmation || !formInputApplies(input, state.values, cargo, state))
+            if (!safe(input.name) || input.form_client === false || input.bind || input.confirmation || !formInputApplies(input, state.values, cargo, state))
                 continue;
             const path = prefix + input.name;
             const required = input.required_when === undefined || formInputApplies({ when: input.required_when }, state.values, cargo, state);
@@ -57,6 +58,8 @@ export function projectForm(session, flows) {
                 // An alternative is a group constraint, not several individually required fields.
                 const members = fields(input.any_of, state, prefix, depth + 1).map(field => ({ ...field, required: false }));
                 const groupLabel = language === 'es' ? input.label_es || input.label : input.label;
+                if (members.length && isCurrent)
+                    askedShown = true;
                 if (members.length)
                     out.push({ name: input.name, path, kind: 'alternatives', label: groupLabel || '', required, exclusive: input.exclusive === true, ...(isCurrent ? { current: true } : {}), fields: members });
             }
@@ -67,6 +70,8 @@ export function projectForm(session, flows) {
                 const snapshot = state.childResults?.[input.name];
                 const virtual = child || { values: state.values?.[input.name] || {}, data: snapshot?.data || {}, prepared: snapshot?.prepared || {}, errors: {} };
                 const nested = fields(child?.specs || input.schema.inputs, virtual, path + '.', depth + 1);
+                if (nested.length && isCurrent)
+                    askedShown = true;
                 if (nested.length)
                     out.push({ name: input.name, path, kind: 'group', label: label(input, language), required, ...(isCurrent ? { current: true } : {}), fields: nested });
             }
@@ -101,17 +106,27 @@ export function projectForm(session, flows) {
                 field.constraints = Object.fromEntries(['min', 'max'].filter(key => typeof profile[key] === 'number').map(key => [key, profile[key]]));
                 if (!field.sensitive && ['string', 'number', 'boolean'].includes(typeof state.values?.[input.name]))
                     field.value = state.values[input.name];
-                if (state.errors?.[input.name])
-                    field.error = String(state.errors[input.name]);
+                // A worded refusal is shown with its field; the bare 'invalid' flag (a refusal with no message, or a whole-form
+                // validator asking for this field) is not caller text: the reply above says what is needed and `current` points here.
+                const error = state.errors?.[input.name];
+                if (error && error !== 'invalid')
+                    field.error = String(error);
                 // The field the conversation is asking for now, so a client can point at it on a redrawn form.
-                if (isCurrent)
+                if (isCurrent) {
                     field.current = true;
+                    askedShown = true;
+                }
                 out.push(field);
             }
         }
         return out;
     };
     const projected = fields(root.specs, root);
+    // A card that cannot take the answer being asked for (a chat-only or not yet prepared field) is not drawn: the
+    // question is answered in chat, never beside a form that has no place for it.
+    const asked = context.names?.length || context.current;
+    if (asked && !askedShown)
+        return null;
     return projected.length ? { version: 1, form: root.id, language, fields: projected } : null;
 }
 /** Host preflight: call before updateActivity. Unknown paths and malformed envelopes never enter execution. */

package/dist/runtime-identity.js

@@ -1 +1 @@
-export const JSFE_RUNTIME_FINGERPRINT = "sha256:66fc7813afb500bc0554e498473cb92a02100e37f3283ccfd6d84471fbd304ee";
+export const JSFE_RUNTIME_FINGERPRINT = "sha256:046178eae674f9484c9ef39ac003f3ebbf6bba8eabe8b51a0b088da24c80eed3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsfe",
-  "version": "1.40.0",
+  "version": "1.40.2",
   "description": "TypeScript workflow engine for conversational/automation apps: multi-flow orchestration, interrupt/resume, stack-based control, robust errors, and flexible tool/REST integration.",
   "license": "MIT",
   "author": "Ron Pinkas",