jsfe 1.6.0 → 1.7.1

package/dist/helpers/index.d.ts

@@ -1,4 +1,9 @@
 export namespace STANDARD_FUNCTIONS {
+    export { readMoneyAmount };
+    export { isMoneyAmount };
+    export { moneyIntentAllows };
+    export { validateMoneyOptions };
+    export { takeChoiceOffer };
     export { matchesChoice };
     export { isAnswer };
     export { isAgentRequest };
@@ -19,11 +24,63 @@ export namespace STANDARD_FUNCTIONS {
     export { normalizeAndFindCapture };
     export { anythingElse };
     export { goodbye };
+    export { sayName };
     export { dateToWords };
     export { amountToSpeech };
     export { validateCardNumber };
     export { validateExpiration };
+    export { consumeActionReceipt };
+    export { authorizeFormActionRetry };
+    export { formSignature };
+    export { selectFormAction };
+    export { confirmFormRevision };
+    export { prepareFormAction };
+    export { actionConfirmationValid };
+    export { beginFormAction };
+    export { finishFormAction };
+    export { actionGateVerified };
+    export { sourceNeedsLoad };
+    export { beginSourceRefresh };
+    export { completeSourceRefresh };
+    export { pickProviderQuestion };
     export { matchInputs };
+    export { readFormAnswer };
+    export { readInputProfile };
+    export { resolveFormInputs };
+    export { formInputApplies };
+    export { formInputFilled };
+    export { nextFormInput };
+    export { formInputChain };
+    export { openFormInstance };
+    export { validateFormIncompleteOutcome };
+    export { formIncompleteOutcome };
+    export { validateFormExhaustion };
+    export { exhaustFormInput };
+    export { formInitialReadings };
+    export { orderFormReadings };
+    export { proposedFormValues };
+    export { applyFormValidation };
+    export { formReadingDependencies };
+    export { exclusiveFormReadings };
+    export { enrichFormMatches };
+    export { expandFormActivations };
+    export { settleFormActivations };
+    export { rememberFormArguments };
+    export { resetFormInputs };
+    export { hasFormValue };
+    export { formPath };
+    export { formValuesEqual };
+    export { formReadingReady };
+    export { formReadingRelevant };
+    export { formPreparation };
+    export { queueFormReadings };
+    export { pendingFormReadings };
+    export { formWorkLimit };
+    export { rejectFormReadings };
+    export { invalidateFormInputs };
+    export { acceptFormReadings };
+    export { formInstanceApplies };
+    export { closeFormInstance };
     export { validateOTP };
     export { validateDigits };
     export { validatePhone };
@@ -31,6 +88,11 @@ export namespace STANDARD_FUNCTIONS {
     export { urlToSpeech };
     export { textWithUrlToSpeech };
 }
+import { readMoneyAmount } from './money.js';
+import { isMoneyAmount } from './money.js';
+import { moneyIntentAllows } from './money.js';
+import { validateMoneyOptions } from './money.js';
+import { takeChoiceOffer } from './choice-offer.js';
 import { matchesChoice } from './matches-choice.js';
 import { ANSWER_WORDS } from './answer.js';
 import { CONFIRM_WORDS } from './answer.js';
@@ -58,7 +120,58 @@ import { dateToWords } from './date-words.js';
 import { amountToSpeech } from './amount-to-speech.js';
 import { validateCardNumber } from './card-checks.js';
 import { validateExpiration } from './card-checks.js';
+import { consumeActionReceipt } from './form-actions.js';
+import { authorizeFormActionRetry } from './form-actions.js';
+import { formSignature } from './form-actions.js';
+import { selectFormAction } from './form-actions.js';
+import { confirmFormRevision } from './form-actions.js';
+import { prepareFormAction } from './form-actions.js';
+import { actionConfirmationValid } from './form-actions.js';
+import { beginFormAction } from './form-actions.js';
+import { finishFormAction } from './form-actions.js';
+import { actionGateVerified } from './form-actions.js';
+import { sourceNeedsLoad } from './form-sources.js';
+import { beginSourceRefresh } from './form-sources.js';
+import { completeSourceRefresh } from './form-sources.js';
+import { pickProviderQuestion } from './form-sources.js';
 import { matchInputs } from './match-inputs.js';
+import { readFormAnswer } from './match-inputs.js';
+import { readInputProfile } from './match-inputs.js';
+import { resolveFormInputs } from './form-state.js';
+import { formInputApplies } from './form-state.js';
+import { formInputFilled } from './form-state.js';
+import { nextFormInput } from './form-state.js';
+import { formInputChain } from './form-state.js';
+import { openFormInstance } from './form-state.js';
+import { validateFormIncompleteOutcome } from './form-state.js';
+import { formIncompleteOutcome } from './form-state.js';
+import { validateFormExhaustion } from './form-state.js';
+import { exhaustFormInput } from './form-state.js';
+import { formInitialReadings } from './form-state.js';
+import { orderFormReadings } from './form-state.js';
+import { proposedFormValues } from './form-state.js';
+import { applyFormValidation } from './form-state.js';
+import { formReadingDependencies } from './form-state.js';
+import { exclusiveFormReadings } from './form-state.js';
+import { enrichFormMatches } from './form-state.js';
+import { expandFormActivations } from './form-state.js';
+import { settleFormActivations } from './form-state.js';
+import { rememberFormArguments } from './form-state.js';
+import { resetFormInputs } from './form-state.js';
+import { hasFormValue } from './form-state.js';
+import { formPath } from './form-state.js';
+import { formValuesEqual } from './form-state.js';
+import { formReadingReady } from './form-state.js';
+import { formReadingRelevant } from './form-state.js';
+import { formPreparation } from './form-state.js';
+import { queueFormReadings } from './form-state.js';
+import { pendingFormReadings } from './form-state.js';
+import { formWorkLimit } from './form-state.js';
+import { rejectFormReadings } from './form-state.js';
+import { invalidateFormInputs } from './form-state.js';
+import { acceptFormReadings } from './form-state.js';
+import { formInstanceApplies } from './form-state.js';
+import { closeFormInstance } from './form-state.js';
 import { checkOtp } from './otp-check.js';
 import { maskDestination } from './otp-check.js';
 import { validateOTP } from './otp-check.js';
@@ -68,5 +181,5 @@ import { validatePhone } from './validators.js';
 import { validateEmail } from './validators.js';
 import { urlToSpeech } from './url-speech.js';
 import { textWithUrlToSpeech } from './url-speech.js';
-export { matchesChoice, ANSWER_WORDS, CONFIRM_WORDS, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice, readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational, normalizeAndFindCapture, anythingElse, goodbye, sayName, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, matchInputs, checkOtp, maskDestination, validateOTP, OTP_EXPIRY_MS, validateDigits, validatePhone, validateEmail, urlToSpeech, textWithUrlToSpeech };
+export { readMoneyAmount, isMoneyAmount, moneyIntentAllows, validateMoneyOptions, takeChoiceOffer, matchesChoice, ANSWER_WORDS, CONFIRM_WORDS, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice, readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational, normalizeAndFindCapture, anythingElse, goodbye, sayName, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, consumeActionReceipt, authorizeFormActionRetry, formSignature, selectFormAction, confirmFormRevision, prepareFormAction, actionConfirmationValid, beginFormAction, finishFormAction, actionGateVerified, sourceNeedsLoad, beginSourceRefresh, completeSourceRefresh, pickProviderQuestion, matchInputs, readFormAnswer, readInputProfile, resolveFormInputs, formInputApplies, formInputFilled, nextFormInput, formInputChain, openFormInstance, validateFormIncompleteOutcome, formIncompleteOutcome, validateFormExhaustion, exhaustFormInput, formInitialReadings, orderFormReadings, proposedFormValues, applyFormValidation, formReadingDependencies, exclusiveFormReadings, enrichFormMatches, expandFormActivations, settleFormActivations, rememberFormArguments, resetFormInputs, hasFormValue, formPath, formValuesEqual, formReadingReady, formReadingRelevant, formPreparation, queueFormReadings, pendingFormReadings, formWorkLimit, rejectFormReadings, invalidateFormInputs, acceptFormReadings, formInstanceApplies, closeFormInstance, checkOtp, maskDestination, validateOTP, OTP_EXPIRY_MS, validateDigits, validatePhone, validateEmail, urlToSpeech, textWithUrlToSpeech };
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAc8B,qBAAqB;6BACkG,aAAa;8BAAb,aAAa;yBAAb,aAAa;+BAAb,aAAa;+BAAb,aAAa;kCAAb,aAAa;+BAAb,aAAa;+BAAb,aAAa;2BAAb,aAAa;0BACT,cAAc;0BAAd,cAAc;uCAAd,cAAc;+BAAd,cAAc;sBAAd,cAAc;0BAAd,cAAc;iCAAd,cAAc;gCAAd,cAAc;sCAAd,cAAc;wCAC/H,cAAc;6BACP,cAAc;wBAAd,cAAc;wBAAd,cAAc;4BACjC,iBAAiB;+BACd,uBAAuB;mCACC,kBAAkB;mCAAlB,kBAAkB;4BAC7C,mBAAmB;yBACuB,gBAAgB;gCAAhB,gBAAgB;4BAAhB,gBAAgB;8BAAhB,gBAAgB;+BACzB,iBAAiB;8BAAjB,iBAAiB;8BAAjB,iBAAiB;4BAC7B,iBAAiB;oCAAjB,iBAAiB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAkBmF,YAAY;8BAAZ,YAAY;kCAAZ,YAAY;qCAAZ,YAAY;gCAlB/D,mBAAmB;8BAiBrB,qBAAqB;6BAEkG,aAAa;8BAAb,aAAa;yBAAb,aAAa;+BAAb,aAAa;+BAAb,aAAa;kCAAb,aAAa;+BAAb,aAAa;+BAAb,aAAa;2BAAb,aAAa;0BACT,cAAc;0BAAd,cAAc;uCAAd,cAAc;+BAAd,cAAc;sBAAd,cAAc;0BAAd,cAAc;iCAAd,cAAc;gCAAd,cAAc;sCAAd,cAAc;wCAC/H,cAAc;6BACP,cAAc;wBAAd,cAAc;wBAAd,cAAc;4BACjC,iBAAiB;+BACd,uBAAuB;mCACC,kBAAkB;mCAAlB,kBAAkB;qCAxB+I,mBAAmB;yCAAnB,mBAAmB;8BAAnB,mBAAmB;iCAAnB,mBAAmB;oCAAnB,mBAAmB;kCAAnB,mBAAmB;wCAAnB,mBAAmB;gCAAnB,mBAAmB;iCAAnB,mBAAmB;mCAAnB,mBAAmB;gCAe1I,mBAAmB;mCAAnB,mBAAmB;sCAAnB,mBAAmB;qCAAnB,mBAAmB;4BAUtD,mBAAmB;+BAAnB,mBAAmB;iCAAnB,mBAAmB;kCAC6mB,iBAAiB;iCAAjB,iBAAiB;gCAAjB,iBAAiB;8BAAjB,iBAAiB;+BAAjB,iBAAiB;iCAAjB,iBAAiB;8CAAjB,iBAAiB;sCAAjB,iBAAiB;uCAAjB,iBAAiB;iCAAjB,iBAAiB;oCAAjB,iBAAiB;kCAAjB,iBAAiB;mCAAjB,iBAAiB;oCAAjB,iBAAiB;wCAAjB,iBAAiB;sCAAjB,iBAAiB;kCAAjB,iBAAiB;sCAAjB,iBAAiB;sCAAjB,iBAAiB;sCAAjB,iBAAiB;gCAAjB,iBAAiB;6BAAjB,iBAAiB;yBAAjB,iBAAiB;gCAAjB,iBAAiB;iCAAjB,iBAAiB;oCAAjB,iBAAiB;gCAAjB,iBAAiB;kCAAjB,iBAAiB;oCAAjB,iBAAiB;8BAAjB,iBAAiB;mCAAjB,iBAAiB;qCAAjB,iBAAiB;mCAAjB,iBAAiB;oCAAjB,iBAAiB;kCAAjB,iBAAiB;yBACzoB,gBAAgB;gCAAhB,gBAAgB;4BAAhB,gBAAgB;8BAAhB,gBAAgB;+BACzB,iBAAiB;8BAAjB,iBAAiB;8BAAjB,iBAAiB;4BAC7B,iBAAiB;oCAAjB,iBAAiB"}

package/dist/helpers/index.js

@@ -1,3 +1,5 @@
+import { takeChoiceOffer } from './choice-offer.js';
+import { consumeActionReceipt, authorizeFormActionRetry, formSignature, selectFormAction, confirmFormRevision, prepareFormAction, actionConfirmationValid, beginFormAction, finishFormAction, actionGateVerified } from './form-actions.js';
 /**
  * jsfe/helpers — the functions JSFE's system flows call from expressions, in ONE place for every host: reading an
  * answer (matchesChoice, pickChoice, isAnswer, readEmail, readIdentifier, amountInAnswer, matchInputs …), saying
@@ -12,7 +14,9 @@
  * Functions that need credentials or the network (sending a text or an email, geocoding, a store's API) belong to the
  * host.
  */
+import { sourceNeedsLoad, beginSourceRefresh, completeSourceRefresh, pickProviderQuestion } from './form-sources.js';
 import { matchesChoice } from './matches-choice.js';
+import { readMoneyAmount, isMoneyAmount, moneyIntentAllows, validateMoneyOptions } from './money.js';
 import { ANSWER_WORDS, CONFIRM_WORDS, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice } from './answer.js';
 import { readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational } from './contact.js';
 import { normalizeAndFindCapture } from './capture.js';
@@ -20,15 +24,16 @@ import { anythingElse, goodbye, sayName } from './phrases.js';
 import { dateToWords } from './date-words.js';
 import { amountToSpeech } from './amount-to-speech.js';
 import { validateCardNumber, validateExpiration } from './card-checks.js';
-import { matchInputs } from './match-inputs.js';
+import { matchInputs, readFormAnswer, readInputProfile } from './match-inputs.js';
+import { resolveFormInputs, formInputApplies, formInputFilled, nextFormInput, formInputChain, openFormInstance, validateFormIncompleteOutcome, formIncompleteOutcome, validateFormExhaustion, exhaustFormInput, formInitialReadings, orderFormReadings, proposedFormValues, applyFormValidation, formReadingDependencies, exclusiveFormReadings, enrichFormMatches, expandFormActivations, settleFormActivations, rememberFormArguments, resetFormInputs, hasFormValue, formPath, formValuesEqual, formReadingReady, formReadingRelevant, formPreparation, queueFormReadings, pendingFormReadings, formWorkLimit, rejectFormReadings, invalidateFormInputs, acceptFormReadings, formInstanceApplies, closeFormInstance } from './form-state.js';
 import { checkOtp, maskDestination, validateOTP, OTP_EXPIRY_MS } from './otp-check.js';
 import { validateDigits, validatePhone, validateEmail } from './validators.js';
 import { urlToSpeech, textWithUrlToSpeech } from './url-speech.js';
-export { matchesChoice, ANSWER_WORDS, CONFIRM_WORDS, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice, readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational, normalizeAndFindCapture, anythingElse, goodbye, sayName, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, matchInputs, checkOtp, maskDestination, validateOTP, OTP_EXPIRY_MS, validateDigits, validatePhone, validateEmail, urlToSpeech, textWithUrlToSpeech, };
+export { readMoneyAmount, isMoneyAmount, moneyIntentAllows, validateMoneyOptions, takeChoiceOffer, matchesChoice, ANSWER_WORDS, CONFIRM_WORDS, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice, readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational, normalizeAndFindCapture, anythingElse, goodbye, sayName, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, consumeActionReceipt, authorizeFormActionRetry, formSignature, selectFormAction, confirmFormRevision, prepareFormAction, actionConfirmationValid, beginFormAction, finishFormAction, actionGateVerified, sourceNeedsLoad, beginSourceRefresh, completeSourceRefresh, pickProviderQuestion, matchInputs, readFormAnswer, readInputProfile, resolveFormInputs, formInputApplies, formInputFilled, nextFormInput, formInputChain, openFormInstance, validateFormIncompleteOutcome, formIncompleteOutcome, validateFormExhaustion, exhaustFormInput, formInitialReadings, orderFormReadings, proposedFormValues, applyFormValidation, formReadingDependencies, exclusiveFormReadings, enrichFormMatches, expandFormActivations, settleFormActivations, rememberFormArguments, resetFormInputs, hasFormValue, formPath, formValuesEqual, formReadingReady, formReadingRelevant, formPreparation, queueFormReadings, pendingFormReadings, formWorkLimit, rejectFormReadings, invalidateFormInputs, acceptFormReadings, formInstanceApplies, closeFormInstance, checkOtp, maskDestination, validateOTP, OTP_EXPIRY_MS, validateDigits, validatePhone, validateEmail, urlToSpeech, textWithUrlToSpeech, };
 /** The functions flows call by name, ready to spread into a host's approved functions. */
 export const STANDARD_FUNCTIONS = {
-    matchesChoice, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice,
+    readMoneyAmount, isMoneyAmount, moneyIntentAllows, validateMoneyOptions, takeChoiceOffer, matchesChoice, isAnswer, isAgentRequest, isOtherRequest, isSpelledFragment, isAmountAnswer, amountInAnswer, pickChoice,
     readEmail, readPhone, readInternationalPhone, readIdentifier, last4, maskEmail, callerTextNumber, textDestination, callerIsInternational,
-    normalizeAndFindCapture, anythingElse, goodbye, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, matchInputs,
+    normalizeAndFindCapture, anythingElse, goodbye, sayName, dateToWords, amountToSpeech, validateCardNumber, validateExpiration, consumeActionReceipt, authorizeFormActionRetry, formSignature, selectFormAction, confirmFormRevision, prepareFormAction, actionConfirmationValid, beginFormAction, finishFormAction, actionGateVerified, sourceNeedsLoad, beginSourceRefresh, completeSourceRefresh, pickProviderQuestion, matchInputs, readFormAnswer, readInputProfile, resolveFormInputs, formInputApplies, formInputFilled, nextFormInput, formInputChain, openFormInstance, validateFormIncompleteOutcome, formIncompleteOutcome, validateFormExhaustion, exhaustFormInput, formInitialReadings, orderFormReadings, proposedFormValues, applyFormValidation, formReadingDependencies, exclusiveFormReadings, enrichFormMatches, expandFormActivations, settleFormActivations, rememberFormArguments, resetFormInputs, hasFormValue, formPath, formValuesEqual, formReadingReady, formReadingRelevant, formPreparation, queueFormReadings, pendingFormReadings, formWorkLimit, rejectFormReadings, invalidateFormInputs, acceptFormReadings, formInstanceApplies, closeFormInstance,
     validateOTP, validateDigits, validatePhone, validateEmail, urlToSpeech, textWithUrlToSpeech,
 };

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

@@ -1,3 +1,8 @@
+/**
+ * One input's reading of the answer: { value, evidence } or null. `evidence` is what the answer spent on it (digits
+ * or words), so two inputs that claim the same part of the answer are told apart from a compound answer.
+ */
+export function readInputProfile(profile: any, answer: any, isCurrent?: boolean): any;
 /**
  * candidates: [{ form, name, profile, value?, confirm_against? }] — the inputs of the form chain that apply now (`when`
  * holds): the current form's first, then its parent's, and so on up. `value` is what is already stored for it.
@@ -19,7 +24,16 @@
  *   hits      — what the answer fills, each { form, name, value, known } (`known`: equals the stored value);
  *   ambiguous — the readings to ask about (the first such group), or empty.
  */
+/** Explicit information questions are a separate answer kind, so their topic is not accepted as a field value.
+ * A question clause is consumed as a question; independently separated clauses remain available for collection. */
+export function readFormAnswer(answer: any, candidates: any, current: any, choiceKey: any, questions?: any[]): {
+    hits: any[];
+    ambiguous: any;
+    remaining: any[];
+    questions: any[];
+};
 export function matchInputs(answer: any, candidates: any, current: any, choiceKey: any): {
+    remaining?: any[] | undefined;
     hits: {
         [x: string]: any;
     }[];

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":"AA0GA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;EAuEC"}
+{"version":3,"file":"match-inputs.d.ts","sourceRoot":"","sources":["../../src/helpers/match-inputs.js"],"names":[],"mappings":"AA2EA;;;GAGG;AACH,sFAmGC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;mHACmH;AACnH;;;;;EAeC;AACD;;;;;;EA6EC"}

package/dist/helpers/match-inputs.js

@@ -11,6 +11,9 @@
 import { matchesChoice } from './matches-choice.js';
 import { pickChoice, amountInAnswer, isAmountAnswer } from './answer.js';
 import { readEmail, readPhone, readInternationalPhone, readIdentifier } from './contact.js';
+import { readSpokenMoney } from './spoken-money.js';
+import { readMoneyAmount, moneyIntentAllows } from './money.js';
+import { pickProviderQuestion } from './form-sources.js';
 /** The answer as said: jsfe stores user input escaped (don\'t). */
 function unescape(answer) {
     return String(answer ?? '').replace(/\\(['"\\])/g, '$1');
@@ -19,32 +22,116 @@ function unescape(answer) {
 function digitRuns(raw) {
     return (raw.match(/\d(?:[\s.-]?\d)*/g) || []).map((r) => r.replace(/\D/g, ''));
 }
+/** Source intervals let different readers recognize the same evidence without agreeing on its type. */
+function numberSpans(raw, value, amount = false) {
+    const runs = [...raw.matchAll(/\d(?:[\s.,-]?\d)*/g)];
+    if (!amount) {
+        const wanted = String(value).replace(/\D/g, '');
+        return runs.filter(m => { const d = m[0].replace(/\D/g, ''); return d === wanted || d === '1' + wanted; })
+            .map(m => [m.index, m.index + m[0].length]);
+    }
+    const spans = [];
+    for (let i = 0; i < runs.length; i++) {
+        for (let j = i; j < runs.length; j++) {
+            const a = runs[i].index, b = runs[j].index + runs[j][0].length;
+            // Include adjacent currency words for cents and dollars-and-cents readings.
+            const tail = (raw.slice(b).match(/^\s*(?:cents?|centavos?|dollars?|d[oó]lares?|pesos?|bucks?)\b/i) || [''])[0];
+            if (amountInAnswer(raw.slice(a, b) + tail) === Number(value)) {
+                spans.push([a, b + tail.length]);
+                break;
+            }
+        }
+    }
+    return spans.filter(([a, b]) => !spans.some(([c, d]) => c >= a && d <= b && (c > a || d < b)));
+}
+function choiceSpans(raw, words) {
+    const tokens = [...raw.matchAll(/[\p{L}\p{N}*#]+/gu)];
+    const spans = [];
+    for (const word of words) {
+        const n = (String(word).match(/[\p{L}\p{N}*#]+/gu) || []).length;
+        for (let i = 0; n && i + n <= tokens.length; i++) {
+            const a = tokens[i].index, b = tokens[i + n - 1].index + tokens[i + n - 1][0].length;
+            if (matchesChoice(raw.slice(a, b), [word]))
+                spans.push([a, b]);
+        }
+    }
+    return spans;
+}
+function emailSpans(raw, value) {
+    const literal = raw.toLowerCase().indexOf(value);
+    if (literal >= 0)
+        return [[literal, literal + value.length]];
+    // Spoken addresses may use at / arroba / dot / punto. Select the shortest source window yielding this address.
+    const tokens = [...raw.matchAll(/\S+/g)];
+    if (tokens.length > 128)
+        return [[0, raw.length]];
+    for (let size = 1; size <= tokens.length; size++) {
+        const spans = [];
+        for (let i = 0; i + size <= tokens.length; i++) {
+            const a = tokens[i].index, b = tokens[i + size - 1].index + tokens[i + size - 1][0].length;
+            if (readEmail(raw.slice(a, b)) === value)
+                spans.push([a, b]);
+        }
+        if (spans.length)
+            return spans;
+    }
+    return [[0, raw.length]];
+}
 /**
  * One input's reading of the answer: { value, evidence } or null. `evidence` is what the answer spent on it (digits
  * or words), so two inputs that claim the same part of the answer are told apart from a compound answer.
  */
-function readProfile(profile, raw, isCurrent) {
+export function readInputProfile(profile, answer, isCurrent = true) {
+    const raw = unescape(answer);
     const kind = profile && profile.kind;
     if (kind === 'choice') {
-        const choices = Array.isArray(profile.choices) ? profile.choices : [];
-        const key = pickChoice(raw, choices, false);
-        if (key && key.indexOf('__') !== 0) {
-            const choice = choices.filter((c) => c && c.key === key)[0] || { words: [] };
-            const words = (choice.words || []).filter((w) => matchesChoice(raw, [w]));
-            // a number word is the same evidence as a number read by another input ('62' as a sub-account and as $62)
-            return { value: key, evidence: words.map((w) => (/^[\d\s.-]+$/.test(String(w)) ? `d:${String(w).replace(/\D/g, '')}` : `w:${String(w).toLowerCase()}`)) };
-        }
-        else {
-            return null; // no choice, or an AGENT / EXIT request (ask-choice owns those)
+        const choices = (Array.isArray(profile.choices) ? profile.choices : []).filter(c => isCurrent || c.current_only !== true).map(c => ({ ...c,
+            numericWords: (c.words || []).filter(word => /^\d{2,}$/.test(String(word).trim())),
+            words: (c.words || []).concat(isCurrent ? c.keys || [] : []).filter(word => !(isAmountAnswer(raw) && /^\d+$/.test(String(word).trim())) && (isCurrent || profile.numeric_values === true || !/^[\d*#]$/.test(String(word).trim()))) }));
+        // Semantic numeric values may arrive in ASR groups ("95 52"), unlike menu keys.
+        // Keep choice policy in pickChoice and source evidence in the original utterance.
+        const runs = digitRuns(raw), joined = raw.replace(/\d(?:[\s.-]?\d)*/g, run => ' ' + run.replace(/\D/g, '') + ' ');
+        const numericSpans = c => {
+            if (isAmountAnswer(raw))
+                return [];
+            const words = c.numericWords.filter(word => runs.includes(String(word).trim()));
+            if (!words.length || pickChoice(joined, [{ ...c, words }], false) !== c.key)
+                return [];
+            return words.flatMap(word => numberSpans(raw, String(word).trim()).filter(([a, b]) => raw.slice(a, b).replace(/\D/g, '') === String(word).trim()));
+        };
+        const base = pickChoice(raw, choices, false);
+        const negative = c => ['no', 'decline', 'done', 'cancel'].includes(c.key) || c.negative === true;
+        const picked = choices.find(c => c.key === base);
+        const pool = picked && negative(picked) ? [picked] : choices.filter(c => !negative(c));
+        let readings = pool.filter(c => pickChoice(raw, [c], false) === c.key || numericSpans(c).length).map(c => {
+            const words = (c.words || []).filter(w => matchesChoice(raw, [w]));
+            const spans = [...choiceSpans(raw, words), ...numericSpans(c)].filter((span, index, all) => all.findIndex(other => other[0] === span[0] && other[1] === span[1]) === index);
+            return { value: c.key, ...(isCurrent && (c.keys || []).length && !isAmountAnswer(raw) && pickChoice(raw, [{ key: c.key, words: c.keys, exact: true }], false) === c.key ? { keypad: true } : {}), spans: spans.length ? spans : [[0, raw.length]], option_label: c.label || (c.words || []).find(w => !/^\d+$/.test(w)) || c.key, option_label_es: c.label_es || c.label || c.key };
+        });
+        // A more specific declared phrase can cover a shorter phrase of the same field's other option.
+        readings = readings.filter(r => !readings.some(other => other !== r && r.spans.every(([a, b]) => other.spans.some(([c, d]) => c <= a && d >= b && (c < a || d > b)))));
+        if (readings.length > 1)
+            return { alternatives: readings };
+        if (readings.length === 1) {
+            const { option_label, option_label_es, ...one } = readings[0];
+            return one;
         }
+        return isCurrent && profile.accept_other === true && raw.trim() ? { value: raw.trim(), spans: [[0, raw.length]] } : null;
     }
     else if (kind === 'amount') {
-        const n = profile.marked ? (isAmountAnswer(raw) ? amountInAnswer(raw) : NaN) : amountInAnswer(raw);
+        const money = profile.money;
+        const read = money ? text => readMoneyAmount(text, money) : amountInAnswer;
+        const refused = !!money && money.intent === 'payment' && !moneyIntentAllows(raw, 'payment');
+        // A refusal is an uncommittable validation candidate, never a numeric correction. A declared
+        // validator may route it to recovery; the common batch always withholds acceptance.
+        if (refused)
+            return Number.isFinite(readMoneyAmount(raw, { ...money, intent: undefined })) ? { value: raw, refused: true, spans: [[0, raw.length]], evidence: ['money-intent'] } : null;
+        const n = (profile.marked === 'out_of_order' ? !isCurrent : profile.marked) ? (isAmountAnswer(raw) ? read(raw) : NaN) : read(raw);
         const inRange = !isNaN(n) && (profile.min === undefined || n >= Number(profile.min)) && (profile.max === undefined || n <= Number(profile.max));
         if (inRange) {
             // the digits it was read from: the runs that start with its whole-dollar part ("82.50" said as "82 50" → 8250)
             const runs = digitRuns(raw).filter((d) => d.indexOf(String(Math.trunc(n))) === 0);
-            return { value: String(n), evidence: runs.length ? runs.map((d) => `d:${d}`) : ['amount'] };
+            return { value: String(n), spans: [...numberSpans(raw, n, true), ...(money?.cardinals ? readSpokenMoney(raw).filter(reading => reading.value === n).map(reading => [reading.start, reading.end]) : [])], evidence: runs.length ? runs.map((d) => `d:${d}`) : ['amount'] };
         }
         else {
             return null;
@@ -53,7 +140,7 @@ function readProfile(profile, raw, isCurrent) {
     else if (kind === 'email') {
         const e = readEmail(raw);
         if (e) {
-            return { value: e, evidence: [`e:${e}`] };
+            return { value: e, spans: emailSpans(raw, e), evidence: [`e:${e}`] };
         }
         else {
             return null;
@@ -62,7 +149,7 @@ function readProfile(profile, raw, isCurrent) {
     else if (kind === 'phone') {
         const p = readPhone(raw) || readInternationalPhone(raw);
         if (p) {
-            return { value: p, evidence: [`d:${String(p).replace(/\D/g, '')}`] };
+            return { value: p, spans: numberSpans(raw, p), evidence: [`d:${String(p).replace(/\D/g, '')}`] };
         }
         else {
             return null;
@@ -71,7 +158,7 @@ function readProfile(profile, raw, isCurrent) {
     else if (kind === 'identifier') {
         const id = readIdentifier(raw, profile.pattern || '');
         if (id && id.kind === 'account') {
-            return { value: id.value, evidence: [`d:${id.value}`] };
+            return { value: id.value, spans: numberSpans(raw, id.value), evidence: [`d:${id.value}`] };
         }
         else {
             return null;
@@ -82,7 +169,7 @@ function readProfile(profile, raw, isCurrent) {
         const max = Number(profile.max || min);
         const fits = [...new Set(digitRuns(raw).filter((d) => d.length >= min && d.length <= max))];
         if (fits.length === 1) {
-            return { value: fits[0], evidence: [`d:${fits[0]}`] };
+            return { value: fits[0], spans: numberSpans(raw, fits[0]), evidence: [`d:${fits[0]}`] };
         }
         else {
             return null; // none, or two different numbers of that length: not this input's answer by shape alone
@@ -98,16 +185,16 @@ function readProfile(profile, raw, isCurrent) {
         }
         if (m) {
             const v = m[profile.group || 0] || m[0];
-            return { value: v, evidence: [`p:${String(v).toLowerCase()}`] };
+            return { value: v, spans: [[m.index + m[0].indexOf(v), m.index + m[0].indexOf(v) + v.length]], evidence: [`p:${String(v).toLowerCase()}`] };
         }
         else {
-            return null;
+            return isCurrent && profile.accept_other === true && raw.trim() ? { value: raw.trim(), fallback: true, spans: [[0, raw.length]] } : null;
         }
     }
     else if (kind === 'text') {
         const t = raw.trim();
         if (isCurrent && t) {
-            return { value: t, evidence: ['text'] };
+            return { value: t, fallback: true, spans: [[0, raw.length]], evidence: ['text'] };
         }
         else {
             return null; // free text fills only the input that was asked, or every answer would fit it
@@ -138,44 +225,62 @@ function readProfile(profile, raw, isCurrent) {
  *   hits      — what the answer fills, each { form, name, value, known } (`known`: equals the stored value);
  *   ambiguous — the readings to ask about (the first such group), or empty.
  */
+/** Explicit information questions are a separate answer kind, so their topic is not accepted as a field value.
+ * A question clause is consumed as a question; independently separated clauses remain available for collection. */
+export function readFormAnswer(answer, candidates, current, choiceKey, questions = []) {
+    const raw = unescape(answer), parts = raw.split(/([?;\n]|\b(?:and|y)\b)/i), asked = [];
+    let consumed = false;
+    const remaining = parts.map(part => {
+        const text = part.trim();
+        if (!/^[¿\s]*(?:how\b|what\b|when\b|where\b|which\b|why\b|who\b|cu[aá]nt[oa]s?\b|qu[eé]\b|cu[aá]ndo\b|d[oó]nde\b|c[oó]mo\b|(?:can|could) you (?:tell|show)\b|(?:i (?:want|would like) to know|tell me|show me|quiero saber|quisiera saber|me gustar[ií]a saber|d[ií]game|dime|mu[eé]strame)\b)/i.test(text))
+            return part;
+        const key = pickProviderQuestion(text, questions);
+        if (!key || key.startsWith('__'))
+            return part;
+        consumed = true;
+        asked.push(key);
+        return ' '.repeat(part.length);
+    }).join('');
+    // Delimiters left by a consumed question are not a free-text field answer.
+    const fieldText = consumed && !/[a-záéíóúüñ0-9]/i.test(remaining.replace(/\b(?:and|y)\b/gi, '')) ? '' : remaining;
+    const matches = matchInputs(consumed ? fieldText : raw, candidates, current, consumed ? '' : choiceKey);
+    const provenance = h => ({ ...h, raw, utterance: raw });
+    return { ...matches, hits: matches.hits.map(provenance), ambiguous: matches.ambiguous.map(provenance), remaining: (matches.remaining || []).map(group => group.map(provenance)), questions: [...new Set(asked)] };
+}
 export function matchInputs(answer, candidates, current, choiceKey) {
     const raw = unescape(answer);
     const list = Array.isArray(candidates) ? candidates.filter((c) => c && c.name && c.profile) : [];
     const cur = current && typeof current === 'object' ? current : {};
     const isCur = (c) => (Array.isArray(cur.names) ? cur.names.indexOf(c.name) > -1 : c.name === cur.name) && (cur.form === undefined || c.form === cur.form);
     const own = Array.isArray(cur.names) ? undefined : list.filter(isCur)[0]; // a group has no single own choice list
-    // A declared confirm_against pair with the current input is read in full below, even when its own choice was picked.
-    const pairedWithOwn = !!own && list.some((c) => c !== own && ((Array.isArray(c.confirm_against) && c.confirm_against.indexOf(own.name) > -1) || (Array.isArray(own.confirm_against) && own.confirm_against.indexOf(c.name) > -1)));
-    if (own && choiceKey && !pairedWithOwn && own.profile.kind === 'choice' && (own.profile.choices || []).some((c) => c && c.key === choiceKey)) {
-        return { hits: [{ form: own.form, name: own.name, value: choiceKey, known: own.value === choiceKey }], ambiguous: [] };
-    }
-    else {
-        // no direct pick of the current input's own choice: read every candidate's shape
-    }
     // A form's scope level: 0 for the current input's form, then each further form in the order the chain lists them.
     const forms = [];
     if (own) {
-        forms.push(own.form);
+        forms.push(own.scope || own.form);
     }
     else {
         // the current input is not among the candidates (it no longer applies): levels follow the list order
     }
-    list.forEach((c) => { if (forms.indexOf(c.form) === -1) {
-        forms.push(c.form);
+    list.forEach((c) => { if (forms.indexOf(c.scope || c.form) === -1) {
+        forms.push(c.scope || c.form);
     }
     else { /* already ranked */ } });
     const readings = [];
     for (const c of list) {
-        const r = readProfile(c.profile, raw, isCur(c));
-        if (r) {
-            readings.push({ form: c.form, name: c.name, value: r.value, known: c.value !== undefined && c.value !== null && String(c.value) === String(r.value), evidence: r.evidence, level: forms.indexOf(c.form), current: isCur(c), confirm: Array.isArray(c.confirm_against) ? c.confirm_against : [] });
+        let r = readInputProfile(c.profile, raw, isCur(c));
+        // A semantic choice supplied by ask-choice (e.g. spoken keypad keys) is a reading, not an early return.
+        if (!r && c === own && choiceKey && c.profile.kind === 'choice' && (c.profile.choices || []).some(x => x.key === choiceKey)) {
+            r = { ...(r || {}), value: choiceKey, spans: r?.spans?.length ? r.spans : [[0, raw.length]] };
         }
-        else {
-            // this input's shape is not in the answer
+        if (r) {
+            for (const option of r.alternatives || [r]) {
+                readings.push({ form: c.form, name: c.name, value: option.value, ...(option.refused === true ? { refused: true } : {}), known: c.value !== undefined && c.value !== null && String(c.value) === String(option.value), spans: option.spans, keypad: option.keypad === true, fallback: option.fallback === true,
+                    ...(r.alternatives ? { option_label: option.option_label, option_label_es: option.option_label_es } : {}), group: c.group, exclusive: c.exclusive === true, level: forms.indexOf(c.scope || c.form), current: isCur(c), confirm: Array.isArray(c.confirm_against) ? c.confirm_against : [] });
+            }
         }
     }
     // Readings that spent the same evidence form a group (connected components).
-    const conflicts = (a, b) => a.evidence.some((e) => b.evidence.indexOf(e) > -1);
+    const conflicts = (a, b) => a.form === b.form && (a.name === b.name && a.value !== b.value || a.exclusive && b.exclusive && a.group && a.group === b.group && a.name !== b.name) || (a.spans || []).some(([s, e]) => (b.spans || []).some(([t, u]) => s < u && t < e));
     const parent = readings.map((_, i) => i);
     const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
     for (let i = 0; i < readings.length; i++) {
@@ -190,15 +295,23 @@ export function matchInputs(answer, candidates, current, choiceKey) {
     }
     const groups = {};
     readings.forEach((r, i) => { (groups[find(i)] = groups[find(i)] || []).push(r); });
-    const strip = ({ evidence, level, current: c, confirm, ...r }) => r;
+    const strip = ({ evidence, spans, keypad, fallback, level, group, exclusive, current: c, confirm, ...r }) => r;
     const paired = (a, b) => a.confirm.indexOf(b.name) > -1 || b.confirm.indexOf(a.name) > -1;
     const hits = [];
     let ambiguous = [];
-    for (const members of Object.values(groups)) {
+    const remaining = [];
+    for (const group of Object.values(groups)) {
+        // Free text is a fallback; a specific claim to the same source evidence is stronger.
+        const specific = group.filter(m => !m.fallback);
+        const members = specific.length ? specific.concat(group.filter(m => m.fallback && specific.some(s => paired(m, s)))) : group;
         let winners;
         if (members.length === 1) {
             winners = members;
         }
+        else if (members.some((m) => m.current && m.keypad)) {
+            // Explicit menu keys select their current field, including a current any_of group.
+            winners = members.filter((m) => m.current && m.keypad);
+        }
         else if (members.some((m) => m.current)) {
             winners = members.filter((m) => m.current);
         }
@@ -216,8 +329,8 @@ export function matchInputs(answer, candidates, current, choiceKey) {
             ambiguous = asked.map(strip);
         }
         else {
-            // a second ambiguous group in one answer is left for the next question
+            remaining.push(asked.map(strip));
         }
     }
-    return { hits, ambiguous };
+    return { hits, ambiguous, ...(remaining.length ? { remaining } : {}) };
 }

package/dist/helpers/money.d.ts

@@ -0,0 +1,12 @@
+/** A profile must declare its currency; currently only USD grammar is supported. No exchange-rate inference. */
+export function validateMoneyOptions(options: any): any;
+/** One declared intent acceptance rule, shared by parsing and domain validation. Uncertainty is not refusal. */
+export function moneyIntentAllows(input: any, intent: any): boolean;
+/** Number or NaN. currency is required; cardinals defaults false and intent is optional.
+ * Explicit foreign currencies, negative amounts and independent unequal readings fail closed.
+ * Refusal is rejected only under the explicitly declared payment intent; it never grants consent.
+ */
+export function readMoneyAmount(input: any, options: any): any;
+/** True exactly when the opted-in reader returns a finite amount (bare digits included). */
+export function isMoneyAmount(input: any, options: any): boolean;
+//# sourceMappingURL=money.d.ts.map

package/dist/helpers/money.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../../src/helpers/money.js"],"names":[],"mappings":"AAIA,gHAAgH;AAChH,wDAGC;AACD,gHAAgH;AAChH,oEAQC;AAWD;;;GAGG;AACH,+DAYC;AACD,4FAA4F;AAC5F,iEAAsG"}

package/dist/helpers/money.js

@@ -0,0 +1,54 @@
+/** Opt-in currency grammar. Existing amountInAnswer/isAmountAnswer retain their published 1.6 semantics. */
+import { numericAmountReading } from './answer.js';
+import { scanSpokenMoney } from './spoken-money.js';
+/** A profile must declare its currency; currently only USD grammar is supported. No exchange-rate inference. */
+export function validateMoneyOptions(options) {
+    if (!options || typeof options !== 'object' || Array.isArray(options) || Object.keys(options).some(key => !['currency', 'cardinals', 'intent'].includes(key)) || options.currency !== 'USD' || options.cardinals !== undefined && typeof options.cardinals !== 'boolean' || options.intent !== undefined && options.intent !== 'payment')
+        throw new Error('Money options require currency USD, optional boolean cardinals and optional payment intent');
+    return options;
+}
+/** One declared intent acceptance rule, shared by parsing and domain validation. Uncertainty is not refusal. */
+export function moneyIntentAllows(input, intent) {
+    if (intent === undefined || intent === null || intent === '')
+        return true;
+    if (intent !== 'payment')
+        throw new Error('Unsupported money intent');
+    const raw = String(input ?? '').replace(/\\(['"\\])/g, '$1').toLowerCase().replace(/[’‘]/g, "'");
+    const refused = /\b(?:can't|cannot|can not|won't|will not|don't|do not|refuse to)\s+(?:want\s+to\s+)?pay(?:\b|(?=\d))|\bno\s+(?:lo\s+)?(?:se\s+)?(?:puede|pudo|puedo|quiero|voy\s+a)\s+pagar(?:\b|(?=\d))/.test(raw);
+    const unable = /\b(?:unable|not able)\s+to\s+pay(?:\b|(?=\d))|\bno\s+(?:soy|somos|es|son)\s+capaz(?:es)?\s+de\s+pagar(?:\b|(?=\d))|\bincapaz\s+de\s+pagar(?:\b|(?=\d))|\b(?:no\s+(?:me\s+)?es\s+posible|me\s+es\s+imposible|no\s+podr[eé])\s+pagar(?:\b|(?=\d))/.test(raw);
+    const deferred = /\b(?:pay|paying|pagar|abonar)(?:\b|(?=\d))/.test(raw) && /\b(?:later|tomorrow|next week|not today|despu[eé]s|m[aá]s tarde|ma[nñ]ana|hasta)\b/.test(raw);
+    return !refused && !unable && !deferred;
+}
+function unsupportedCurrency(raw) {
+    return /(?:^|[^a-záéíóúüñ])(?:pesos?|mxn|euros?|eur|pounds?|gbp|yen|jpy|cad|aud|nzd|hkd|sgd|chf|canadian|canadienses?|australian|australianos?)(?![a-záéíóúüñ])|[€£¥₱₹₩₽]|\bmx\s*\$/i.test(raw);
+}
+function negativeAmount(raw) {
+    return /\b(?:minus|negative|menos|negativo)\b|(?:^|[\s,(;:])[-−]\s*\$?\s*(?:\d|[a-záéíóúüñ])/i.test(raw);
+}
+/** Explicit identifier labels cannot become amounts merely because their number words precede a currency. */
+function introducedAsIdentifier(raw, start) {
+    return /\b(?:sub[ -]?accounts?|accounts?|subcuentas?|cuentas?|cards?(?:\s+number)?|tarjetas?|ending(?:\s+in)?|terminad[ao]s?\s+en|que\s+termina\s+en|termina\s+en|codes?|c[oó]digos?|zip(?:\s+code)?|postal|n[uú]mero|number)\s*(?:de\s+|is\s+|es\s+)?$/i.test(raw.slice(0, start));
+}
+/** Number or NaN. currency is required; cardinals defaults false and intent is optional.
+ * Explicit foreign currencies, negative amounts and independent unequal readings fail closed.
+ * Refusal is rejected only under the explicitly declared payment intent; it never grants consent.
+ */
+export function readMoneyAmount(input, options) {
+    validateMoneyOptions(options);
+    const raw = String(input ?? '').replace(/\\(['"\\])/g, '$1');
+    if (unsupportedCurrency(raw) || negativeAmount(raw) || !moneyIntentAllows(raw, options.intent))
+        return NaN;
+    const { readings, invalid } = scanSpokenMoney(raw);
+    if (invalid.length || options.cardinals !== true && readings.length || readings.some(reading => introducedAsIdentifier(raw, reading.start)))
+        return NaN;
+    const numeric = readings.reduce((text, reading) => text.slice(0, reading.start) + ' '.repeat(reading.end - reading.start) + text.slice(reading.end), raw);
+    const remaining = numericAmountReading(numeric);
+    if (!readings.length)
+        return remaining.value;
+    if (remaining.candidates && Number.isNaN(remaining.value))
+        return NaN;
+    const values = readings.map(reading => reading.value).concat(Number.isNaN(remaining.value) ? [] : [remaining.value]);
+    return new Set(values).size === 1 ? values[0] : NaN;
+}
+/** True exactly when the opted-in reader returns a finite amount (bare digits included). */
+export function isMoneyAmount(input, options) { return Number.isFinite(readMoneyAmount(input, options)); }