jsfe 1.10.0 → 1.10.1

package/dist/helpers/match-inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match-inputs.d.ts","sourceRoot":"","sources":["../../src/helpers/match-inputs.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,sEAQC;AAqED;;;GAGG;AACH,sFAwGC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;mHACmH;AACnH;;;;;;;;;;;;;;;;;;;;;EAeC;AACD;;;;;;;;;;;;;;;;;;;;;;EA0KC"}
+{"version":3,"file":"match-inputs.d.ts","sourceRoot":"","sources":["../../src/helpers/match-inputs.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,sEAQC;AAqED;;;GAGG;AACH,sFAwGC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;mHACmH;AACnH;;;;;;;;;;;;;;;;;;;;;EAeC;AACD;;;;;;;;;;;;;;;;;;;;;;EAgLC"}

package/dist/helpers/match-inputs.js

@@ -303,8 +303,9 @@ export function matchInputs(answer, candidates, current, choiceKey) {
         // Rule 2: a confirmation is answered only when asked, firm by CONFIRM_WORDS, soft by the wider YES vocabulary.
         const confirmation = ['firm', 'soft'].includes(c.confirmation) ? c.confirmation : '';
         if (confirmation && !isCur(c)) {
-            if (readInputProfile(c.profile, raw, false))
-                refused.push({ form: c.form, name: c.name, rule: 'confirmation_out_of_order' });
+            const would = readInputProfile(c.profile, raw, false);
+            if (would)
+                refused.push({ form: c.form, name: c.name, rule: 'confirmation_out_of_order', spans: (would.alternatives || [would]).flatMap((x) => x.spans || []) });
             continue;
         }
         else {
@@ -353,11 +354,11 @@ export function matchInputs(answer, candidates, current, choiceKey) {
             return true;
         }
         else if (bare(reading) && fieldOf(reading).profile.kind === 'amount') {
-            refused.push({ form: reading.form, name: reading.name, value: reading.value, rule: 'bare_amount_out_of_order' });
+            refused.push({ form: reading.form, name: reading.name, value: reading.value, rule: 'bare_amount_out_of_order', spans: reading.spans });
             return false;
         }
         else if (/\d/.test(spanText(reading)) && !wholeRuns(reading)) {
-            refused.push({ form: reading.form, name: reading.name, value: reading.value, rule: 'fragment' });
+            refused.push({ form: reading.form, name: reading.name, value: reading.value, rule: 'fragment', spans: reading.spans });
             return false;
         }
         else {
@@ -454,7 +455,12 @@ export function matchInputs(answer, candidates, current, choiceKey) {
     const clash = (a, b) => (a.spans || []).some(([s, e]) => (b.spans || []).some(([t, u]) => s < u && t < e));
     const kept = taken.filter((a) => !taken.some((b) => b !== a && clash(a, b)));
     for (const r of taken.filter((a) => !kept.includes(a)))
-        refused.push({ form: r.form, name: r.name, value: r.value, rule: 'one_part_two_fields' });
+        refused.push({ form: r.form, name: r.name, value: r.value, rule: 'one_part_two_fields', spans: r.spans });
+    // A refusal is recorded only when it stopped something: a reading whose part of the answer a structured in-order
+    // reading (a key, the code, the amount asked) also claimed would have lost anyway ("2" at PAY or LINK is the key, not
+    // an amount refused). A free-text fallback claims everything and does not count.
+    const claimed = readings.filter((r) => inOrder(r) && !r.fallback).flatMap((r) => r.spans || []);
+    const stopped = refused.filter((x) => !(x.spans || []).some(([s, e]) => claimed.some(([t, u]) => s < u && t < e))).map(({ spans, ...x }) => x);
     // Several fields from one answer: those filled out of order are a compound answer.
     if (kept.length > 1)
         kept.forEach((r) => { if (r.rule === 'out_of_order')
@@ -462,5 +468,5 @@ export function matchInputs(answer, candidates, current, choiceKey) {
     hits.push(...kept.map(({ rule, ...r }) => strip(r)));
     // Why each field was filled other than as the current answer, kept beside the hits so their shape never changes.
     const decisions = kept.filter((r) => r.rule).map((r) => ({ form: r.form, name: r.name, rule: r.rule }));
-    return { hits, ambiguous, ...(remaining.length ? { remaining } : {}), ...(refused.length ? { refused } : {}), ...(decisions.length ? { decisions } : {}) };
+    return { hits, ambiguous, ...(remaining.length ? { remaining } : {}), ...(stopped.length ? { refused: stopped } : {}), ...(decisions.length ? { decisions } : {}) };
 }

package/dist/runtime-identity.js

@@ -1 +1 @@
-export const JSFE_RUNTIME_FINGERPRINT = "sha256:6f3a7201cfa214cba9a28fb392f8d61c4d731287b90a56b89cf191968d9edf56";
+export const JSFE_RUNTIME_FINGERPRINT = "sha256:a185d7c855be017ff45741150eea0f426254c3eb2de5069c5d8f40fec198054b";

package/docs/development-release.md

@@ -1,3 +1,10 @@
+## 1.10.1: refusals that stopped something
+
+`matchInputs` lists a refused reading only when it stopped something: one whose part of the answer a structured in-order
+reading (a key, the code, the amount asked) also claimed would have lost anyway, so "2" at a menu is its key, not a refused
+amount, and the host's `form_acceptance` counts real leaks. A free-text fallback does not count as a claim. The
+standard-functions test recognizes named function expressions and arrow functions a flow defines for itself.
+
 ## 1.10.0: context-aware acceptance
 
 An answer given out of order fills another question's field only where it is relevant there (reference §5): a confirmation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsfe",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "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",