jsfe 1.15.9 → 1.16.0

package/README.md

@@ -12,6 +12,7 @@ npm i jsfe
 - **[JavaScript Flow Engine User Guide](user-guide.md)** 
 - Comprehensive tutorials, examples, and best practices
 - **[README.md](README.md)** - Technical API reference (this document)
+- **[Flows architecture guide](docs/architecture-guide.md)** - start here: the concepts, the building blocks, what the caller experiences, and how conversational AI and exact transactional flows work together (the reply ranker and DISPATCH)
 - **[Flow author reference](docs/copilot-reference.md)** - the authoritative engine and JSON authoring specification for flow authors and AI flow generators (shipped in the package; the Flow Designer's CoPilot reads it from the published version, so change it with the engine)
 - **[Development candidate acceptance](docs/development-release.md)** - reproducible package and cross-repository verification
 - **[System Flows](docs/flows/system/README.md)** and **[Shopify Flows](docs/flows/shopify/README.md)** - the bundled flow and tool libraries in `flows/`: a page and a chart per flow, generated from the JSON (`node scripts/flow-docs.mjs`), plus the conventions the system flows share

package/dist/docs/flow-docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flow-docs.d.ts","sourceRoot":"","sources":["../../src/docs/flow-docs.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;EAqRC"}
+{"version":3,"file":"flow-docs.d.ts","sourceRoot":"","sources":["../../src/docs/flow-docs.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;EAsRC"}

package/dist/docs/flow-docs.js

@@ -14,8 +14,10 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { resolveSetDataReferences } from '../forms/declarations.js';
 export function generateFlowDocs({ sets, root, check = false, hostRun = {}, log = console.log }) {
-    const SETS = sets;
+    // A catalog or value written as {"$data": path} is documented as compilation resolves it.
+    const SETS = sets.map((s) => ({ ...s, flows: resolveSetDataReferences(s.flows) }));
     // Which set holds a flow id; a page links to a flow in its own set, or in another set's folder.
     const setOf = new Map(), flowOf = new Map();
     for (const s of SETS) {
@@ -422,7 +424,7 @@ export function generateFlowDocs({ sets, root, check = false, hostRun = {}, log
         }
         else { /* not a compiled form */ }
         if (flow.performs) {
-            out.push('', '### Performs', '', ...flow.performs.map((a) => `- \`${a.action}\` (${a.effect}): ${a.reconcile && a.reconcile.policy ? cut(a.reconcile.policy, 300) : ''}`), '', performsChart(flow));
+            out.push('', '### Performs', '', ...flow.performs.map((a) => `- \`${a.action}\` (${a.effect})`), '', performsChart(flow));
         }
         else { /* not a performer */ }
         if (flow.call) {

package/dist/forms/address-flows.js

@@ -28,7 +28,7 @@ const street = C('address-street-validate', 'Validate a proposed street against
     W('address_street_malformed', "!/^\\d{1,6}\\s+[A-Za-z\\xC0-\\xFF]/.test(String(value))", S('address_street_invalid', 'noop', "(cargo.inputCheck={ok:false,message:'Please give the street number and street name.',message_es:'Indique el número y nombre de la calle.'},true)")), W('address_street_stop', "!/^\\d{1,6}\\s+[A-Za-z\\xC0-\\xFF]/.test(String(value))", { id: 'address_street_invalid_end', type: 'END' }),
     S('address_street_components', 'components', "'postal_code:'+values.zip+'|country:US'"), { id: 'address_street_tool', type: 'CALL-TOOL', tool: 'geocode-street', variable: 'result', args: { address: '{{value}}', components: '{{components}}' }, onFail: S('address_street_failed', 'result', 'null') },
     S('address_street_projection', 'location', E(streetLocation, 'result', 'value', 'values.zip')),
-    S('address_street_result', 'noop', "(cargo.forms[form].data.street=location, cargo.inputCheck={ok:true,value:String(value)}, true)")
+    S('address_street_result', 'noop', "(cargo.forms[form].data.street=location, location.city&&cargo.forms[form].accepted&&cargo.forms[form].accepted.city&&cargo.forms[form].accepted.city.origin==='derived'&&cargo.forms[form].values.city!==location.city?(cargo.forms[form].values.city=location.city):null, cargo.inputCheck={ok:true,value:String(value)}, true)")
 ], { parameters: [P('form'), P('value'), P('values', 'object')], variables: V({ components: '', result: null, location: null }), contract: { tools: ['geocode-street'], result: { path: 'cargo.inputCheck', type: 'object' } } });
 const zipPrompt = C('address-zip-prompt', 'Render the ZIP retry wording from the owned address instance.', [S('address_zip_prompt', 'noop', "(cargo.forms[form].data.zip_question=(cargo.forms[form].data.retry ? \"Let's try again. \" : '')+'What is the 5-digit zip code of your new address?',cargo.forms[form].data.zip_question_es=(cargo.forms[form].data.retry?'Intentémoslo otra vez. ':'')+'¿Cuál es el código postal de 5 dígitos de su nueva dirección?',true)")], { parameters: [P('form')], contract: { result: { path: 'cargo.forms[form].data', type: 'object' } } });
 const streetPrompt = C('address-street-prompt', 'Include the ZIP-derived location when asking for the street.', [S('address_street_prompt', 'noop', "(cargo.forms[form].data.street_question=(cargo.forms[form].data.location?'Got it, '+(cargo.forms[form].values.city?cargo.forms[form].values.city+', '+cargo.forms[form].data.location.state:cargo.forms[form].data.location.line)+'. ':'')+'What is the street address?',cargo.forms[form].data.street_question_es=(cargo.forms[form].data.location?'Entendido, '+(cargo.forms[form].values.city?cargo.forms[form].values.city+', '+cargo.forms[form].data.location.state:cargo.forms[form].data.location.line)+'. ':'')+'¿Cuál es la dirección?',true)")], { parameters: [P('form')], contract: { result: { path: 'cargo.forms[form].data', type: 'object' } } });

package/dist/forms/continuation-compat.d.ts

@@ -0,0 +1,5 @@
+export function continuationBreaks(previousFlows: any, nextFlows: any): {
+    id: any;
+    removed: {};
+}[];
+//# sourceMappingURL=continuation-compat.d.ts.map

package/dist/forms/continuation-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuation-compat.d.ts","sourceRoot":"","sources":["../../src/forms/continuation-compat.js"],"names":[],"mappings":"AAgBA;;;IAgBC"}

package/dist/forms/continuation-compat.js

@@ -0,0 +1,45 @@
+/**
+ * A deploy check: a change that can break a saved session must bump its declaration's major version. A saved session
+ * continues across a minor or patch change, so an entry argument or a form input it may still hold must not disappear
+ * without a major bump; neither may a shared data or function name without its entry's major bump. Removing a flow needs
+ * no bump: a session standing in a flow that no longer exists is retired anyway.
+ *
+ *   continuationBreaks(previousFlows, nextFlows) → [{ id, removed: { parameters?, inputs?, data?, functions? } }]
+ *     both arrays are the authored declarations (a set's .flows file); ordinary executable flows are not compared.
+ * It reads names only: a change of meaning under the same name is still the author's to declare with a major bump.
+ */
+import { majorOf } from './declarations.js';
+const parameterNames = parameters => Array.isArray(parameters) ? parameters.map(p => p?.name).filter(Boolean) : Object.keys(parameters || {});
+const inputNames = inputs => (inputs || []).flatMap(input => [input?.name, ...inputNames(input?.any_of)]).filter(Boolean);
+const missing = (before, after) => { const keep = new Set(after); return [...new Set(before)].filter(name => !keep.has(name)); };
+export function continuationBreaks(previousFlows, nextFlows) {
+    const next = new Map((nextFlows || []).filter(flow => flow && flow.id).map(flow => [flow.id, flow]));
+    const breaks = [];
+    for (const before of previousFlows || []) {
+        const after = before && next.get(before.id);
+        if (!after || before.declarationVersion === undefined || majorOf(before.version) !== majorOf(after.version))
+            continue;
+        const removed = {};
+        if (before.library === 'data') {
+            const names = missing(Object.keys(before.data || {}), Object.keys(after.data || {}));
+            if (names.length)
+                removed.data = names;
+        }
+        else if (before.library === 'functions') {
+            const names = missing(Object.keys(before.functions || {}), Object.keys(after.functions || {}));
+            if (names.length)
+                removed.functions = names;
+        }
+        else {
+            const parameters = missing(parameterNames(before.parameters), parameterNames(after.parameters));
+            if (parameters.length)
+                removed.parameters = parameters;
+            const inputs = missing(inputNames(before.form?.inputs), inputNames(after.form?.inputs));
+            if (inputs.length)
+                removed.inputs = inputs;
+        }
+        if (Object.keys(removed).length)
+            breaks.push({ id: before.id, removed });
+    }
+    return breaks;
+}

package/dist/forms/contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../src/forms/contracts.js"],"names":[],"mappings":"AAgBA;;;IAGC;AACD;;;;;EAGC;AACD,qGAAqG;AACrG;;QAwCC;AAqBD;;;QAEC;AAgBD;;;;;;;;;QASC;AACD;;;;QAGC;AACD;;;;;;;;QA8BC;AAED,mHAAmH;AACnH,kDAgBC;AAED,+GAA+G;AAC/G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2EC"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../src/forms/contracts.js"],"names":[],"mappings":"AAgBA;;;IAGC;AACD;;;;;EAGC;AACD,qGAAqG;AACrG;;QAwCC;AAqBD;;;QAEC;AAgBD;;;;;;;;;QASC;AACD;;;;QAGC;AACD;;;;;;;;QA8BC;AAED,mHAAmH;AACnH,kDAgBC;AAED,+GAA+G;AAC/G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EC"}

package/dist/forms/contracts.js

@@ -138,7 +138,7 @@ export function defineProvider({ provides, contract, parameters = [], variables
 }
 export function defineForm({ contract, provides, ...spec }) {
     const flow = formFlow({ ...spec, ...(provides ? { extraVars: { ...spec.extraVars, provides, questions: providerQuestions(provides) } } : {}) });
-    return declared(flow, { role: 'collector', ...contract, form: { inputs: 'inputs' } });
+    return declared(flow, { role: 'collector', ...contract, form: { inputs: 'inputs' }, ...(provides ? { catalog: 'provides' } : {}) });
 }
 export function definePerformer({ performs, contract, prepare, present, project = [], provides, ...spec }) {
     validateActionProjection(project, spec.id);
@@ -170,7 +170,7 @@ export function definePerformer({ performs, contract, prepare, present, project
             { ...set('receipt_applied', 'noop', 'pf_receipt ? consumeActionReceipt(cargo,pf_receipt) : true'), requireTrue: true },
             call('present', present, { form: '{{form_instance}}', request: '{{pf_request}}', result: '{{pf_result}}' }),
             ...(spec.after || [])] });
-    return declared(flow, { role: 'performer', ...contract, requires: ['guardedActions', ...normalizeHostRequirements(contract?.requires, spec.id)], actions: 'performs', form: { inputs: 'inputs' }, prepares: prepare, presents: present, projects: 'projection' });
+    return declared(flow, { role: 'performer', ...contract, requires: ['guardedActions', ...normalizeHostRequirements(contract?.requires, spec.id)], actions: 'performs', form: { inputs: 'inputs' }, prepares: prepare, presents: present, projects: 'projection', ...(provides ? { catalog: 'provides' } : {}) });
 }
 /** A registered tool gets one generated adapter with explicit args; no dynamic tool-name interpreter is needed. */
 export function operationWorkers(tools) {
@@ -278,6 +278,10 @@ export function validateFlowContracts(flows, tools = [], { externalFlows = [], r
             for (const reference of [provides.gate?.flow, provides.source?.flow])
                 if (reference && !ids.has(reference))
                     fail(flow.id, `unknown provider worker ${reference}`);
+            // a FLOW to a name that does not exist is skipped silently at run time, so a menu choice's target is checked here
+            for (const choice of provides.menu?.choices || [])
+                if (choice?.flow && !ids.has(choice.flow))
+                    fail(flow.id, `unknown menu worker ${choice.flow}`);
         }
         for (const action of contract.performs || flow.variables?.[contract.actions]?.value || []) {
             if (action.retry?.unknown && !(action.effect === 'send' && action.retry.unknown === 'explicit'))
@@ -292,8 +296,6 @@ export function validateFlowContracts(flows, tools = [], { externalFlows = [], r
                 fail(flow.id, `unknown action worker ${action.flow}`);
             if (!action.outcomes || !Object.keys(action.outcomes).length)
                 fail(flow.id, `action ${action.action} needs outcomes`);
-            if (['charge', 'write', 'send', 'cancel'].includes(action.effect) && !action.idempotency && !action.reconcile)
-                fail(flow.id, `action ${action.action} needs idempotency or reconciliation`);
             if ((action.effect === 'charge' || action.effect === 'cancel' || action.reversible === false) && action.confirm?.exact !== true)
                 fail(flow.id, `action ${action.action} needs exact confirmation`);
         }

package/dist/forms/declarations.d.ts

@@ -1,6 +1,7 @@
 /** The set's shared data for expressions, read as $data.<name>: references resolved, deep-frozen (one engine serves many
  * sessions), never copied into session variables. Every $data.<name> an expression reads must exist, checked at load. */
 export function flowSetData(flows: any, compiledFlows?: any[]): any;
+export function resolveSetDataReferences(flows: any): any;
 /** Compile only explicitly versioned declarations. Ordinary executable JSON is unchanged.
  * @param {any[]} flows
  * @param {{tools?: any[], externalFlows?: any[], validate?: boolean}} options
@@ -20,4 +21,6 @@ export function captureOriginalDeclaration(flow: any): {
 export function serializeFlowDeclaration(flow: any, { resolvedFlow }?: {
     resolvedFlow?: any;
 }): any;
+/** The major of a declared version ("2.4.1" → "2"; absent or unreadable → "0"). */
+export function majorOf(version: any): string;
 //# sourceMappingURL=declarations.d.ts.map

package/dist/forms/declarations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/forms/declarations.js"],"names":[],"mappings":"AAgDA;yHACyH;AACzH,oEAaC;AAmFD;;;;GAIG;AACH,+CAJW,GAAG,EAAE,uCACL;IAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAC,GACxD,GAAG,EAAE,CAmEjB;AAED,sGAAsG;AACtG;;;SAAqK;AAuBrK,6FAA6F;AAC7F;;QAuCC"}
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/forms/declarations.js"],"names":[],"mappings":"AAyDA;yHACyH;AACzH,oEAaC;AAID,0DAIC;AAmFD;;;;GAIG;AACH,+CAJW,GAAG,EAAE,uCACL;IAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAC,GACxD,GAAG,EAAE,CAuEjB;AAED,sGAAsG;AACtG;;;SAAqK;AAuBrK,6FAA6F;AAC7F;;QAuCC;AAnSD,mFAAmF;AACnF,8CAA4G"}

package/dist/forms/declarations.js

@@ -12,6 +12,15 @@ const fail = message => { throw new Error('Flow declaration: ' + message); };
 function sourceRevision(source) { const text = JSON.stringify(source); const hashes = [2166136261, 2246822507, 3266489909, 668265263]; for (let i = 0; i < text.length; i++)
     for (let lane = 0; lane < hashes.length; lane++)
         hashes[lane] = Math.imul(hashes[lane] ^ text.charCodeAt(i), 16777619 + lane * 2) >>> 0; return hashes.map(n => n.toString(16).padStart(8, '0')).join(''); }
+/** The major of a declared version ("2.4.1" → "2"; absent or unreadable → "0"). */
+const majorOf = version => { const m = /^\s*v?(\d+)/i.exec(String(version ?? '')); return m ? String(Number(m[1])) : '0'; };
+/** A declaration's continuation revision: its major version, plus the major of each shared entry it uses ($data, fn.).
+ * A minor or patch change keeps the revision, so a saved session continues; a breaking change bumps the major. */
+function majorRevision(declarationVersion, source, libraries) {
+    const text = JSON.stringify(source), uses = { data: /\$data\b/.test(text), functions: /(?<![\w$])fn\./.test(text) };
+    const shared = libraries.filter(library => uses[library.library]).map(library => library.library + '@' + library.id + ':' + majorOf(library.version)).sort();
+    return 'declaration-v' + declarationVersion + ':major:' + majorOf(source.version) + (shared.length ? '/' + shared.join('/') : '');
+}
 const variableDeclaration = value => value && typeof value === 'object' && !Array.isArray(value) && ['string', 'number', 'integer', 'boolean', 'object', 'array'].includes(value.type) ? value : { type: Array.isArray(value) ? 'array' : value === null || typeof value === 'object' ? 'object' : typeof value, value };
 const DECLARATION_VERSIONS = new Set([1, 2]);
 /** A flow set's shared entries: {id, library:'functions', declarationVersion:2, functions} and
@@ -29,7 +38,7 @@ function sharedFunctions(libraries) {
             fail('a shared functions entry needs an id');
         if (library.declarationVersion !== 2)
             fail('shared functions ' + library.id + ' require declarationVersion 2');
-        const extra = Object.keys(library).filter(key => !['id', 'name', 'library', 'declarationVersion', 'description', 'functions'].includes(key));
+        const extra = Object.keys(library).filter(key => !['id', 'name', 'library', 'declarationVersion', 'description', 'version', 'functions'].includes(key));
         if (extra.length)
             fail('shared functions ' + library.id + ' cannot declare ' + extra.join(', '));
         if (!library.functions || typeof library.functions !== 'object' || Array.isArray(library.functions) || !Object.keys(library.functions).length)
@@ -51,7 +60,7 @@ function sharedData(libraries) {
             fail('a shared data entry needs an id');
         if (library.declarationVersion !== 2)
             fail('shared data ' + library.id + ' requires declarationVersion 2');
-        const extra = Object.keys(library).filter(key => !['id', 'name', 'library', 'declarationVersion', 'description', 'data'].includes(key));
+        const extra = Object.keys(library).filter(key => !['id', 'name', 'library', 'declarationVersion', 'description', 'version', 'data'].includes(key));
         if (extra.length)
             fail('shared data ' + library.id + ' cannot declare ' + extra.join(', '));
         if (!library.data || typeof library.data !== 'object' || Array.isArray(library.data) || !Object.keys(library.data).length)
@@ -88,6 +97,15 @@ export function flowSetData(flows, compiledFlows = []) {
     }
     return Object.keys(resolved).length ? resolved : undefined;
 }
+/** A set's version 2 declarations with every {"$data":"path"} replaced by its value, as compilation sees them; the shared
+ * data entries are kept. For readers of the declarations (the flow docs); compilation resolves them itself. */
+export { majorOf };
+export function resolveSetDataReferences(flows) {
+    const data = sharedData((flows || []).filter(isLibrary));
+    if (!Object.keys(data).length)
+        return flows;
+    return flows.map(flow => flow?.declarationVersion === 2 && !isLibrary(flow) ? resolveDataReferences(flow, data, flow.id) : flow);
+}
 const isDataReference = value => !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 1 && typeof value.$data === 'string';
 /** Replace every {"$data":"path"} with a copy of the shared value at that path; an unknown path fails compilation. */
 function resolveDataReferences(value, data, where, active = new Set()) {
@@ -266,7 +284,11 @@ export function compileFlowDeclarations(flows, { tools, externalFlows = [], vali
                 return false; parameterNames.add(parameter.name); return true; }), ...(rest.parameterInstructions !== undefined ? { parameterInstructions: rest.parameterInstructions } : {}), ...(functions ? { functions } : {}), metadata: { ...flow.metadata, declaration: { version: declarationVersion, source: source.id } } };
         // Revisions are engine bookkeeping; a stale authored token cannot override source change detection.
         const { safetyRevision: ignoredRevision, ...revisionSource } = source;
-        return withSafetyRevision(flow, 'declaration-v' + declarationVersion + ':' + sourceRevision(declarationVersion === 2 && Object.keys(shared).length ? { ...revisionSource, sharedFunctions: shared } : revisionSource));
+        const revised = withSafetyRevision(flow, majorRevision(declarationVersion, original, libraries));
+        // The earlier revision, a fingerprint of the whole declaration: a session saved under it continues while the declaration
+        // is unchanged (and takes the major revision), so moving to major revisions retires no session.
+        revised.safetyRevisionCompat = 'declaration-v' + declarationVersion + ':' + sourceRevision(declarationVersion === 2 && Object.keys(shared).length ? { ...revisionSource, sharedFunctions: shared } : revisionSource);
+        return revised;
     });
     const externalObjects = externalFlows.filter(flow => flow && typeof flow === 'object');
     const formIds = new Set(flows.filter(flow => flow.declarationVersion !== undefined && flow.form).map(flow => flow.id));
@@ -472,7 +494,7 @@ export function serializeFlowDeclaration(flow, { resolvedFlow = flow } = {}) {
     else if (spec.variables)
         result.variables = spec.variables;
     for (const [key, value] of Object.entries(spec))
-        if (!sharedKeys.includes(key) && !['extraVars', 'variables', 'helpers', 'safetyRevision'].includes(key) && !(isForm && formKeys.has(key)))
+        if (!sharedKeys.includes(key) && !['extraVars', 'variables', 'helpers', 'safetyRevision', 'safetyRevisionCompat'].includes(key) && !(isForm && formKeys.has(key)))
             result[key] = value;
     const out = rewrite(result);
     // Helpers and bodies can reference other explicitly authored expressions as well.

package/dist/forms/flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flows.d.ts","sourceRoot":"","sources":["../../src/forms/flows.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DC;AACD;;;GAGG;AACH;;;;;;EAGC;AAgfD,wHAAwH;AACxH,wEAaC;AACD,4FAA4F;AAC5F;;;EAYC;AACD,sGAAsG;AACtG;;;EAOC;AArrBM,6CAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA82B9G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOG"}
+{"version":3,"file":"flows.d.ts","sourceRoot":"","sources":["../../src/forms/flows.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DC;AACD;;;GAGG;AACH;;;;;;EAGC;AAsfD,wHAAwH;AACxH,wEAaC;AACD,4FAA4F;AAC5F;;;EAYC;AACD,sGAAsG;AACtG;;;EAOC;AA3rBM,6CAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAo3B9G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOG"}

package/dist/forms/flows.js

@@ -459,20 +459,26 @@ const readFormChoice = {
 // form's other choices (a correction) and a person, never YES. Result: cargo.confirmRanked = 'no' | 'changed' | 'none'
 // (ConfirmForm reads it); `abort` ends every flow; `new_request` goes to intent detection.
 const readConfirmReply = {
-    id: 'read-confirm-reply', name: 'ReadConfirmReply', version: '1.2.0', scope: 'isolated', description: 'Rank an unreadable answer to a confirmation: it declines (NO), picks another of the form\'s choices (a correction, read as that input\'s answer), asks for a person, or is asked again; a withdrawal or a new request leaves with saved form progress. Never confirms.',
-    parameters: [{ name: 'form', type: 'string' }, { name: 'question', type: 'string' }, { name: 'question_es', type: 'string' }],
-    variables: vars({ question: '', question_es: '', asked: '', ranked: [], reply: null, chain: null, others: [], picked: null, reading: null }),
+    id: 'read-confirm-reply', name: 'ReadConfirmReply', version: '1.3.0', scope: 'isolated', description: 'Rank an unreadable answer to a confirmation: it declines (NO), picks another of the form\'s choices (a correction, read as that input\'s answer), says a named field read back is wrong (confirm.named_fields: that input is asked again), asks for a person, or is asked again; a withdrawal or a new request leaves with saved form progress. Never confirms.',
+    parameters: [{ name: 'form', type: 'string' }, { name: 'question', type: 'string' }, { name: 'question_es', type: 'string' }, { name: 'named_fields', type: 'boolean' }],
+    variables: vars({ question: '', question_es: '', asked: '', ranked: [], reply: null, chain: null, others: [], fields: [], field: null, picked: null, reading: null, named_fields: false }),
     steps: [SET('confirm_asked', 'asked', "language === 'es' && question_es ? question_es : question"),
         SET('confirm_chain', 'chain', 'formInputChain(cargo.forms, form, cargo)'),
         SET('confirm_others', 'others', otherChoicesJS("''", '[]')),
-        rankedChoices('confirm_ranked_choices', "[{key:'no',label:'no: declines or refuses what the question asks to confirm'}].concat(others.map(function(c){return {key:c.key,label:c.label};}))"),
+        // confirm.named_fields: a field read back may be corrected in the caller's own words ('es Long Beach' at an address
+        // read back with the ZIP code's city): each named input of this form that holds a value is offered, and a pick asks
+        // that input again, so the caller's value replaces the one read back
+        SET('confirm_fields', 'fields', "named_fields === true || named_fields === 'true' ? (chain || []).filter(function(i){var v=cargo.forms[form] && cargo.forms[form].values;return i.form===form && !i.confirmation && Array.isArray(i.names) && i.names.length && v && v[i.name]!==undefined && v[i.name]!==null && v[i.name]!=='';}).map(function(i){var l=String(i.label || i.names[0]);return {key:'field:'+i.name,label:'says the '+l+' read back is wrong, or gives a different '+l,owner:{form:i.form,name:i.name}};}) : []"),
+        rankedChoices('confirm_ranked_choices', "[{key:'no',label:'no: declines or refuses what the question asks to confirm'}].concat(others.map(function(c){return {key:c.key,label:c.label};})).concat(fields.map(function(c){return {key:c.key,label:c.label};}))"),
         rankedDispatch('confirm_dispatch', 'confirmation_not_matched'),
         ...escapeRoutes('confirm_escape'),
         // a correction picked by the ranker is read as its input's answer: the form changes and is confirmed again, never confirmed
         SET('confirm_picked', 'picked', "others.filter(function(c){return reply && c.key===reply.key;})[0] || null"),
         SET('confirm_read', 'reading', "picked ? enrichFormMatches(readFormAnswer(picked.key, chain, picked.owner, picked.key, []), chain, form, [picked.owner.name], picked.owner.name) : null"),
         WHEN('confirm_change', 'reading && reading.hits.length', FLOW('confirm_change_accept', 'collect-input-accept', 'call', { hits: '{{reading.hits}}' })),
-        SIDE('confirm_ranked', "(cargo.confirmRanked=reading && reading.hits.length ? 'changed' : reply && reply.key==='no' ? 'no' : 'none',true)")]
+        SET('confirm_field', 'field', "fields.filter(function(c){return reply && c.key===reply.key;})[0] || null"),
+        WHEN('confirm_field_reset', 'field', SIDE('confirm_field_ask', '(resetFormInputs(cargo, field.owner.form, [field.owner.name]), true)')),
+        SIDE('confirm_ranked', "(cargo.confirmRanked=reading && reading.hits.length || field ? 'changed' : reply && reply.key==='no' ? 'no' : 'none',true)")]
 };
 const collectContextualAnswer = formFlow({ id: 'collect-contextual-answer', name: 'CollectContextualAnswer', description: 'Collect one open-ended answer using contextual DISPATCH and preserve the caller wording.',
     parameters: [...['question', 'question_es', 'description', 'context', 'context_es'].map(name => ({ name, type: 'string' })), { name: 'choices', type: 'array' }, { name: 'digits', type: 'object' }],
@@ -597,7 +603,7 @@ const confirmForm = {
                 'condition: cf_named': SET('cf_named_reset', 'cf_result', "(resetFormInputs(cargo, cf_named.form, [cf_named.name]), 'changed')"),
                 "condition: cargo.choice === 'no'": SET('cf_declined', 'cf_result', "'no'"),
                 "condition: Array.isArray(clarifications) && pickChoice(String(cargo.choiceText || '').replace(/[?¿]/g,''),[{key:'clarify',phrases:clarifications,exact:true}],false)==='clarify'": SET('cf_clarification', 'cf_result', "'clarification'"),
-                'condition: !cf_must && cf_words > 0': FLOW('cf_elsewhere', 'read-confirm-reply', 'call', { form: '{{form}}', question: '{{cf_prompt}}', question_es: '{{cf_prompt_es}}' }),
+                'condition: !cf_must && cf_words > 0': FLOW('cf_elsewhere', 'read-confirm-reply', 'call', { form: '{{form}}', question: '{{cf_prompt}}', question_es: '{{cf_prompt_es}}', named_fields: '{{named_fields}}' }),
                 default: SET('cf_unclear', 'cf_result', "'unclear'")
             } },
         // the ranker's reading of an unread answer: a decline is the NO; an answer that declines nothing is asked again

package/dist/forms/identity-flows.d.ts

@@ -5,6 +5,7 @@ export function serviceDigits(text: any): string;
 export function otpDigits(text: any): string;
 export function contactPrompt(cargo: any, options: any, callerAllowed: any, partial?: boolean, es?: boolean): string;
 export function contactError(kind: any, options: any, es?: boolean): string;
+export function otpWhere(cargo: any, es?: boolean): string;
 export function otpPrompt(cargo: any, es?: boolean): string;
 export function emailReadback(address: any, voice: any, es?: boolean): string;
 /** Reenter the existing owning FORM or its gate without making the owner its own parent. */

package/dist/forms/identity-flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity-flows.d.ts","sourceRoot":"","sources":["../../src/forms/identity-flows.js"],"names":[],"mappings":"AA2BA,+GAA+G;AAC/G,oFAOC;AAQD,wFAAwF;AACxF,iDAGC;AACD,6CAMC;AACD,qHAQC;AAMD,4EAKC;AAoFD,4DAKC;AAmHD,8EAGC;AA4BD,4FAA4F;AAC5F;;;;EAOC;AAQD,0BAAmI"}
+{"version":3,"file":"identity-flows.d.ts","sourceRoot":"","sources":["../../src/forms/identity-flows.js"],"names":[],"mappings":"AA2BA,+GAA+G;AAC/G,oFAOC;AAQD,wFAAwF;AACxF,iDAGC;AACD,6CAMC;AACD,qHAQC;AAMD,4EAKC;AAwFD,2DAKC;AACD,4DAMC;AAuHD,8EAGC;AA4BD,4FAA4F;AAC5F;;;;EAOC;AAQD,0BAAmI"}

package/dist/forms/identity-flows.js

@@ -95,6 +95,9 @@ const contact = worker('get-cell-or-email', 'GetCellOrEmail', 'Identify a suppli
         when('identity_contact_partial_reset', '!contact_partial', effect('identity_contact_partial_forget', "(cargo.gcePartial='',true)")),
         set('identity_contact_allowed', 'contact_allowed', "!!cargo.callerId && !callerIsInternational(cargo) && !cargo.callerDeclined && contact_options.caller_on_file !== 'no'"),
         set('identity_contact_prefill', 'contact_prefill', "String(acct_number || cell_number || email || (!contact_partial && contact_allowed && contact_options.caller_on_file === 'yes' ? cargo.callerId : ''))"),
+        // a question answered from what is already known (the caller ID, a contact given) is never spoken: its intro (why the
+        // account is needed) leads the verification code question instead (otpPrompt). A spoken question said it (or had none).
+        effect('identity_contact_intro_unsaid', "(!contact_prefill ? (cargo.otpIntro='',cargo.otpIntro_es='') : contact_options.intro && !cargo.contactIntroSkip && !contact_options.fromMenu ? (cargo.otpIntro=String(contact_options.intro),cargo.otpIntro_es=String(contact_options.intro_es || contact_options.intro)) : true,true)"),
         effect('identity_contact_preselected', "(acct_number || cell_number || email ? true : (cargo.callerPreselected=!!(contact_prefill && contact_options.caller_on_file === 'yes')),true)"),
         set('identity_contact_profiles', 'contact_profiles', "contact_profiles_base.map(function (field) {return field.name === 'account' ? Object.assign({},field,{profile:{kind:'identifier',pattern:contact_options.account_pattern || '(?!)'}}) : field;}).concat(contact_allowed ? [{name:'caller_decision',label:'caller ID choice',label_es:'opción del identificador de llamadas',profile:{kind:'choice',choices:[{key:'yes',phrases:['1','yes','si','sí'],exact:true},{key:'no',phrases:['no','nope','nah'],exact:true}]}}] : [])"),
         set('identity_contact_keypad', 'contact_keypad', "(function () {var shapes=[{first:'23456789',lengths:[10]},{first:'1',lengths:[11]}].concat(contact_options.account_shape || []);if(contact_partial){var left=[];(contact_options.account_shape || []).forEach(function(s){(s.lengths || []).forEach(function(n){var rest=n-String(cargo.gcePartial).length;if(rest>0 && left.indexOf(rest)<0)left.push(rest);});});return {min:1,max:12,autoSubmitMs:3000,complete:[{first:'0123456789',lengths:left.sort(function(a,b){return a-b;})}]};}return {min:7,max:12,autoSubmitMs:3000,autoSubmitChars:contact_allowed?['1']:[],complete:shapes};})()"),
@@ -171,16 +174,28 @@ const auth = worker('authenticate-user', 'AuthenticateUser', 'Authenticate a con
         cases('auth_complete', { 'condition: cargo.otpVerified === true': set('auth_ok', 'auth_result', 'true'), 'condition: cargo.authRetry': end('auth_return_retry'), default: otpMenu('auth_retry_code', "I couldn't verify your account. You can try again or use another contact.", 'No pude verificar su cuenta. Puede intentarlo de nuevo o usar otro contacto.', true) }),
         call('auth_gate_end', 'task-gate', { form: '{{parent_form}}', gate: 'authenticate-user', active: false })
     ] });
+// Where the code went, for a caller who asks ('¿dónde está?'): the channel and the masked destination, never the code.
+export function otpWhere(cargo, es = false) {
+    const number = String(cargo.otp_cell_number || '').replace(/\D/g, '').slice(-4), tail = cargo.voice ? number.split('').join(', ') : number;
+    if (cargo.otpSentOn === 'whatsapp')
+        return es ? 'Se lo acabo de enviar aquí en este chat.' : 'I just sent it to you here in this chat.';
+    if (cargo.otp_cell_number)
+        return es ? 'Se lo envié por mensaje de texto al celular que termina con ' + tail + '. Revise sus mensajes de texto.' : 'I sent it by text message to the cell ending with ' + tail + '. Check your text messages.';
+    return es ? 'Se lo envié por correo electrónico a ' + String(cargo.otp_email || '') + '. Revise su correo.' : 'I sent it by email to ' + String(cargo.otp_email || '') + '. Check your email.';
+}
 export function otpPrompt(cargo, es = false) {
     const verb = es ? cargo.verb_es : cargo.verb, number = String(cargo.otp_cell_number || '').replace(/\D/g, '').slice(-4), tail = cargo.voice ? number.split('').join(', ') : number;
     const where = cargo.otpSentOn === 'whatsapp' ? (es ? 'que le acabo de enviar aquí en este chat' : 'I just sent you here in this chat') : (es ? 'que recibió en ' : 'you received at ') + (cargo.otp_cell_number ? (es ? 'celular que termina con ' : 'cell ending with ') + tail : (es ? 'correo electrónico: ' : 'email: ') + String(cargo.otp_email || ''));
     const name = cargo.callerPreselected && cargo.callerNamed && cargo.displayName ? cargo.displayName : '';
-    return (name ? name + (es ? ', por favor' : ', please') : es ? 'Por favor' : 'Please') + ' ' + verb + ' ' + (cargo.voice ? es ? 'o ingrese ' : 'or enter ' : '') + (es ? 'el código de verificación de 6 dígitos ' : 'the 6-digit verification code ') + where + '. ' + (es ? `También puede ${cargo.voice ? 'presionar * o decir' : 'escribir'} SALIR para cancelar.` : `You can also ${cargo.voice ? 'press * or ' : ''}${verb} EXIT to cancel.`) + (cargo.callerPreselected ? (es ? ` Para usar otra cuenta, ${verb} OTRA CUENTA.` : ` To use another account, ${verb} ANOTHER ACCOUNT.`) : '');
+    const lead = String((es ? cargo.otpIntro_es : cargo.otpIntro) || '');
+    return (lead ? lead + ' ' : '') + (name ? name + (es ? ', por favor' : ', please') : es ? 'Por favor' : 'Please') + ' ' + verb + ' ' + (cargo.voice ? es ? 'o ingrese ' : 'or enter ' : '') + (es ? 'el código de verificación de 6 dígitos ' : 'the 6-digit verification code ') + where + '. ' + (es ? `También puede ${cargo.voice ? 'presionar * o decir' : 'escribir'} SALIR para cancelar.` : `You can also ${cargo.voice ? 'press * or ' : ''}${verb} EXIT to cancel.`) + (cargo.callerPreselected ? (es ? ` Para usar otra cuenta, ${verb} OTRA CUENTA.` : ` To use another account, ${verb} ANOTHER ACCOUNT.`) : '');
 }
 const OTP_PROFILES = [{ name: 'code', label: 'verification code', label_es: 'código de verificación', profile: { kind: 'digits', min: 6, max: 6 } }, raw];
 const code = worker('get-and-validate-otp-code', 'GetAndValidateOtpCode', 'Collect a one-time-code answer through the owning FORM ancestry, preserving protocol commands for validation.', { variables: vars({ otp_code: '', user_choice: '', normalized_otp_code: '', otp_question: '', otp_question_es: '', otp_profiles: OTP_PROFILES }), contract: { role: 'collector', summary: 'One-time-code answer collector using shared FORM matching' }, steps: [
         when('otp_already_verified', 'cargo.otpVerified === true', end('otp_existing_verification')),
         set('otp_question', 'otp_question', expression(otpPrompt, 'cargo')), set('otp_question_es', 'otp_question_es', expression(otpPrompt, 'cargo', 'true')),
+        // a contact question's unsaid intro (identity_contact_intro_unsaid) leads the first code question only
+        effect('otp_intro_said', "(cargo.otpIntro='',cargo.otpIntro_es='',true)"),
         call('otp_collect', 'collect-service-answer', { profiles: '{{otp_profiles}}', question: '{{otp_question}}', question_es: '{{otp_question_es}}', keypad: { min: 6, max: 6 }, parent_form: '{{cargo.authOptions.parent_form}}', stop_path: 'cargo.otpVerified', context: 'account verification', context_es: 'verificación de cuenta' }),
         when('otp_verified_by_join', 'cargo.otpVerified === true', end('otp_join_finished')),
         set('otp_answer', 'otp_code', "String(cargo.serviceAnswer.values.code || cargo.serviceAnswer.raw || '')"), set('otp_choice', 'user_choice', 'otp_code.trim().toLowerCase()'), set('otp_digits', 'normalized_otp_code', expression(otpDigits, 'otp_code')),
@@ -206,8 +221,8 @@ function otpPhoneUnavailable(value) {
 // What the reply ranker may take at the code question beside the code: the step's offers. Email and another account are
 // offered only where the step offers them (a code sent by text; a caller-ID preselection).
 const OTP_REPLY_CHOICES = [{ key: 'email', label: 'use the email on the account instead of the phone' }, { key: 'another_account', label: 'use another account' },
-    { key: 'resend', label: 'the code did not arrive; send it again' }, { key: 'no_phone', label: 'no longer has that phone or number' }, { key: '__agent', label: 'speak with a person (a live agent)' }];
-const validateCode = worker('validate-otp-code', 'ValidateOtpCode', 'Validate a challenge response with explicit bounded retries, alternate-contact handling and tenant callbacks.', { variables: vars({ otp_phrases: OTP_WORDS, no_code_given: false, wants_other_account: false, other_account_given: false, otp_validation_result: false, whatsapp_invite_sent: false, invite_text: '', otp_cancel: 'contact-support', answer_key: '', answer_value: '', otp_reply_choices: OTP_REPLY_CHOICES, otp_offers: [], otp_reply: {} }), contract: { role: 'gate', summary: 'Validate the active one-time challenge', tools: ['validate-otp', 'send-whatsapp-invite'], result: { path: 'cargo.otpVerified', type: 'boolean' } }, steps: [
+    { key: 'where', label: 'asks where the code is or where it was sent, or cannot find it' }, { key: 'resend', label: 'the code did not arrive; send it again' }, { key: 'no_phone', label: 'no longer has that phone or number' }, { key: '__agent', label: 'speak with a person (a live agent)' }];
+const validateCode = worker('validate-otp-code', 'ValidateOtpCode', 'Validate a challenge response with explicit bounded retries, alternate-contact handling and tenant callbacks.', { variables: vars({ otp_phrases: OTP_WORDS, no_code_given: false, wants_other_account: false, other_account_given: false, otp_validation_result: false, whatsapp_invite_sent: false, invite_text: '', otp_cancel: 'contact-support', answer_key: '', answer_value: '', otp_reply_choices: OTP_REPLY_CHOICES, otp_offers: [], otp_reply: {}, otp_where: '', otp_where_es: '' }), contract: { role: 'gate', summary: 'Validate the active one-time challenge', tools: ['validate-otp', 'send-whatsapp-invite'], result: { path: 'cargo.otpVerified', type: 'boolean' } }, steps: [
         set('otp_cancel', 'otp_cancel', "cargo.authCancelFlow || 'contact-support'"),
         set('otp_reset_no_code', 'no_code_given', 'false'), set('otp_reset_invite', 'whatsapp_invite_sent', 'false'), set('otp_reset_callback', 'answer_key', "''"),
         when('otp_tenant_code', 'cargo.authOptions && cargo.authOptions.code_validator && normalized_otp_code.length !== 6 && /[0-9]/.test(user_choice)', call('otp_tenant_code_call', '{{cargo.authOptions.code_validator}}', { answer: '{{user_choice}}' })),
@@ -243,10 +258,12 @@ const validateCode = worker('validate-otp-code', 'ValidateOtpCode', 'Validate a
             + ".concat(((typeof $callers !== 'undefined' && $callers && $callers['authenticate-user']) || []).map(function(c){return {key:'usecase:'+c.id,label:'states the reason for the call: '+c.label};}))"
             + ".concat(((typeof $gateExits !== 'undefined' && $gateExits && $gateExits['authenticate-user']) || []).map(function(a){return {key:'exit:'+a.key,label:a.label,route:'new_request'};}))"),
         when('otp_off_topic', 'no_code_given', { id: 'otp_reply_rank', type: 'DISPATCH', onResponse: 'continue', responseContext: 'Please say the 6-digit verification code I sent you. (Por favor diga el código de verificación de 6 dígitos que le envié.)', responseChoices: 'otp_offers', responseVariable: 'otp_reply', onNoIntent: 'stay' }),
+        set('otp_where', 'otp_where', expression(otpWhere, 'cargo')), set('otp_where_es', 'otp_where_es', expression(otpWhere, 'cargo', 'true')),
         set('otp_reply_picked', 'no_code_given', "no_code_given && !(otp_reply && otp_reply.key && String(otp_reply.key).indexOf('usecase:') !== 0)"),
         cases('otp_reply_route', {
             "condition: !no_code_given && otp_reply && otp_reply.key === 'email'": call('otp_ranked_email', 'authenticate-user', { cell_number: '', email: '', retrying: true, declined_caller: true }, 'replace'),
             "condition: !no_code_given && otp_reply && otp_reply.key === 'another_account'": call('otp_ranked_account', 'authenticate-user', { cell_number: '', email: '', retrying: true, declined_caller: true }, 'replace'),
+            "condition: !no_code_given && otp_reply && otp_reply.key === 'where'": say('otp_ranked_where', '{{otp_where}}', '{{otp_where_es}}'),
             "condition: !no_code_given && otp_reply && otp_reply.key === 'resend'": call('otp_ranked_resend', 'resend-otp-code', { resend_reason: 'requested' }),
             "condition: !no_code_given && otp_reply && otp_reply.key === 'no_phone'": otpMenu('otp_ranked_no_phone', "No problem. Then the code can't reach you there. You can use the email on your account instead, or {{cargo.verb}} AGENT to reach a person.", 'No hay problema. Entonces el código no le puede llegar ahí. Puede usar el correo electrónico de su cuenta, o {{cargo.verb_es}} AGENTE para hablar con una persona.', false),
             "condition: !no_code_given && otp_reply && otp_reply.key === '__agent'": call('otp_ranked_agent', 'live-agent-requested', undefined, 'reboot'),

package/dist/forms/index.d.ts

@@ -2,6 +2,7 @@ export const FLOWS: any[];
 export { FLOWS as IDENTITY_FLOWS } from "./identity-flows.js";
 export { compileFormPrompts } from "./prompt-compiler.js";
 export { explainSession } from "./inspection.js";
+export { continuationBreaks } from "./continuation-compat.js";
 export { inheritFlowDeclaration } from "./declaration-capture.js";
 export { withSafetyRevision, CONTINUATION_SAFETY_REQUIREMENT } from "./continuation-safety.js";
 export { FIELD_PRESETS, formFlow, declinedFlow, textValue } from "./flows.js";

package/dist/forms/index.js

@@ -13,4 +13,5 @@ export { addressDraft, zipLocation, streetLocation, resolvedAddress } from '../h
 export { explainSession } from './inspection.js';
 export { Form, Provider, Performer, Worker, compileExpression } from './authoring.js';
 export { compileFlowDeclarations, serializeFlowDeclaration, captureOriginalDeclaration } from './declarations.js';
+export { continuationBreaks } from './continuation-compat.js';
 export { inheritFlowDeclaration } from './declaration-capture.js';

package/dist/helpers/address.d.ts

@@ -16,6 +16,7 @@ export function streetLocation(result: any, said: any, zip: any): {
     street: string;
     said: string;
     verified: boolean;
+    city: any;
 };
 export function resolvedAddress(values: any, data: any): {
     street: any;

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

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/helpers/address.js"],"names":[],"mappings":"AAAA,uFAAuF;AACvF;;;;;EAQC;AACD;;;;;SASC;AACD,gDAEC;AACD;;;;EAMC;AACD;;;;;;;;EAIC"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/helpers/address.js"],"names":[],"mappings":"AAAA,uFAAuF;AACvF;;;;;EAQC;AACD;;;;;SASC;AACD,gDAEC;AACD;;;;;EASC;AACD;;;;;;;;EAIC"}

package/dist/helpers/address.js

@@ -27,7 +27,10 @@ export function streetLocation(result, said, zip) {
     const part = kind => components.find(c => (c.types || []).includes(kind))?.long_name || '';
     const types = row.types || [], locationType = row.location_type || row.geometry?.location_type || '';
     const exact = result?.status === 'OK' && row.partial_match !== true && types.includes('street_address') && locationType === 'ROOFTOP' && part('street_number') && part('route') && (!part('postal_code') || part('postal_code') === zip);
-    return { street: exact ? part('street_number') + ' ' + part('route') : String(said).trim(), said: String(said).trim(), verified: !!exact };
+    // An exact street match names the place its mail carries; it corrects a city read from the ZIP code alone (90805 is
+    // Lakewood to the ZIP lookup, while its streets are Long Beach and Lakewood)
+    const city = exact ? part('locality') || part('postal_town') || part('sublocality') : '';
+    return { street: exact ? part('street_number') + ' ' + part('route') : String(said).trim(), said: String(said).trim(), verified: !!exact, city };
 }
 export function resolvedAddress(values, data) {
     const unit = /^(none|no|ninguno|ninguna|sin|no hay)$/i.test(String(values.unit || '')) ? '' : String(values.unit || '').replace(/^(apt\.?|unit|#)\s*/i, '');

package/dist/helpers/form-actions.js

@@ -1,4 +1,4 @@
-/** Session-owned action state. Backend idempotency and reconciliation remain explicit parts of the action contract. */
+/** Session-owned action state. */
 import { nextFormInput, formPath, formInputApplies } from './form-state.js';
 export function formSignature(value) {
     return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)

package/dist/index.d.ts

@@ -393,6 +393,7 @@ export interface FlowDefinition {
     description: string;
     version: string;
     safetyRevision?: string;
+    safetyRevisionCompat?: string;
     primary?: boolean;
     wraps?: string;
     interruptable?: boolean;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AAyB1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAA4B,MAAM,sBAAsB,CAAC;AAyBvF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,EAAE,CASxD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,EAAE,CASxD;AAGD;;;;;;;;;;;;GAYG;AAIH,qBAAa,kBAAmB,SAAQ,KAAK;aACE,KAAK,CAAC,EAAE,KAAK;gBAA9C,OAAO,EAAE,MAAM,EAAkB,KAAK,CAAC,EAAE,KAAK,YAAA;CAI3D;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAG/D,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IACjD,gBAAgB,CAAC,EAAE;QAEjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,eAAe,CAAC;CACrB;AA+LD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EpC,CAAC;AAIF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAuB7G;AAGD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoBtE;AAGD,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,UAAU,CAAC;AAG5H,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAGnC,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;CAC/D;AAUD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;AAEhK,6DAA6D;AAC7D,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,4EAA4E;AAC5E,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChE,KAAK,EAAE;QACL,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,uBAAuB,EAAE,CAAC;KACvC,EAAE,CAAC;CACL;AAED,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,gBAAgB,CAAC;AAI1F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC,mHAAmH;IACnH,iBAAiB,CAAC,EAAE,SAAS,GAAG,cAAc,CAAC;IAC/C,2BAA2B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IACpD,sBAAsB,CAAC,EAAE;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,MAAM,CAAC,EAAC,MAAM,CAAA;KAAC,CAAC;IACxD,sBAAsB,CAAC,EAAE;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAA,OAAO,EAAC,MAAM,CAAC;QAAA,WAAW,EAAC,MAAM,CAAA;KAAC,CAAC;IAC7E,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,oBAAoB,CAAC,EAAE;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAA,KAAK,EAAC,MAAM,CAAC,MAAM,EAAC,GAAG,CAAC,CAAA;KAAC,CAAC;IAClE,gBAAgB,CAAC,EAAE;QAAC,GAAG,EAAC,MAAM,CAAC;QAAA,QAAQ,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,YAAY,CAAC;QAAA,MAAM,CAAC,EAAC,MAAM,CAAC;QAAA,IAAI,CAAC,EAAC,OAAO,CAAC;QAAA,MAAM,CAAC,EAAC,MAAM,CAAA;KAAC,CAAC;IACvH,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,YAAY,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;IAC1B,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,YAAY,EAAE;QAAE,IAAI,CAAC,EAAE,YAAY,CAAC;QAAC,SAAS,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;IAChE,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,qBAAqB,CAAC,EAAE,eAAe,EAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,eAAe,CAAC,EAAE,WAAW,CAAC;IAC9B,iBAAiB,CAAC,EAAE,cAAc,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,cAAc,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;CAC/C;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,CAAC,EAAE;QAAC,OAAO,EAAC,CAAC,CAAC;QAAA,IAAI,EAAC,MAAM,CAAC;QAAA,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,CAAC,EAAC,MAAM,CAAC;QAAA,IAAI,CAAC,EAAC,MAAM,CAAA;KAAC,CAAC;IAC3E,kBAAkB,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACzC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,WAAW,GAAG,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAClE,iBAAiB,CAAC,EAAE,KAAK,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;QACnD,YAAY,CAAC,EAAE,QAAQ,CAAC;KACzB,CAAC,CAAC;IAGH,eAAe,CAAC,EAAE;QAChB,QAAQ,CAAC,EAAE,KAAK,CAAC;YACf,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,CAAC;YAChB,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC,CAAC;QACH,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IAC5B,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,KAAK,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,GAAG,SAAS,CAAC;IACrE,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAGD,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe;IAanF,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,SAAS,GAAG,OAAmB,GAAG,IAAI;IAiB9I,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAInG,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAe7C,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAKnD,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAKnD,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAEhD,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAKhE;AAmDD,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,QAAQ,EAAE,CAAC;IAC3B,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,WAAW,EAAE,eAAe,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,eAAe,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAGD,MAAM,MAAM,MAAM,GAAG,cAAc,CAAC;AAEpC,wIAAwI;AACxI,MAAM,WAAW,eAAe;IAC9B,kBAAkB,EAAE,CAAC,GAAG,CAAC,CAAC;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,UAAU,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAIlB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IAIxB,KAAK,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC9B,UAAU,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAGvC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC,CAAC;IACH,QAAQ,CAAC,EAAE;QACT,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAI/C,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;KAC7C,CAAC;IACF,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAC5C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;IACF,cAAc,CAAC,EAAE;QACf,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,UAAU,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,eAAe,CAAC,EAAE,aAAa,CAAC;QAChC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QAGjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,cAAc,CAAC,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,SAAS,CAAC,EAAE;YACV,QAAQ,EAAE,MAAM,CAAC;YACjB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH,CAAC;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1F,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,CAAC,YAAY,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CACvE;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;CAC7D;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAmBD,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,oBAAoB,CAAC;QACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,CAAC,CAAC;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,CAAC;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,eAAe,CAAC;QACpB,IAAI,EAAE,aAAa,CAAC;KACrB,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,aAAa,GAAG,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,GAAG,KAAK,GAAG,UAAU,GAAG,aAAa,GAAG,gBAAgB,GAAG,YAAY,GAAG,QAAQ,CAAC;IACzY,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,EAAE,EAAE,eAAe,CAAC;QACpB,IAAI,EAAE,OAAO,CAAC;KACf,CAAC,CAAC;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,IAAI,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,aAAa,GAAG,IAAI,GAAG,UAAU,GAAG,IAAI,GAAG,oBAAoB,GAAG,KAAK,GAAG,iBAAiB,GAAG,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,IAAI,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;IAC3S,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,aAAa,GACrB,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,GAClB,qBAAqB,GACrB,wBAAwB,GACxB,UAAU,GACV,MAAM,GACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA2X5B;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AA2iDD,0GAA0G;AAC1G,OAAO,EAAC,0BAA0B,EAAC,MAAM,gCAAgC,CAAC;AAo0B1E,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAGnG;AAED,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CA8HxJ;AA89GD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BpE;AAED;;;;;;GAMG;AACH;;;;GAIG;AACH,2GAA2G;AAC3G,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAUvH;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CA0B7G;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAkCxE;AAED,qBAAa,cAAe,YAAW,MAAM;IAC3C,OAAO,CAAC,kBAAkB,CAAyC;IACnE,uGAAuG;IACvG,IAAW,iBAAiB,IAAI,SAAS,GAAG,cAAc,CAAoC;IAC9F,IAAW,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAI5D;IACD,2GAA2G;IACpG,aAAa,CAAC,EAAE;QACrB,KAAK,CAAC,KAAK,EAAE;YAAC,SAAS,EAAC,MAAM,CAAC;YAAA,MAAM,EAAC,GAAG,CAAC;YAAA,MAAM,EAAC,GAAG,CAAC;YAAA,UAAU,CAAC,EAAC,GAAG,CAAA;SAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QACrF,QAAQ,CAAC,KAAK,EAAE;YAAC,SAAS,EAAC,MAAM,CAAC;YAAA,MAAM,EAAC,GAAG,CAAC;YAAA,MAAM,EAAC,GAAG,CAAC;YAAA,OAAO,EAAC,GAAG,CAAC;YAAA,UAAU,CAAC,EAAC,GAAG,CAAA;SAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QACpG,UAAU,CAAC,KAAK,EAAE;YAAC,SAAS,EAAC,MAAM,CAAC;YAAA,IAAI,CAAC,EAAC,MAAM,EAAE,CAAC;YAAA,QAAQ,CAAC,EAAC,KAAK,CAAC;gBAAC,GAAG,EAAC,MAAM,CAAC;gBAAA,QAAQ,EAAC,MAAM,CAAA;aAAC,CAAC,CAAA;SAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QACpH,OAAO,CAAC,KAAK,EAAE;YAAC,SAAS,EAAC,MAAM,CAAA;SAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;KAClD,CAAC;IACF,OAAO,CAAC,6BAA6B,CAAC,CAA+D;IACrG,6FAA6F;IAChF,yBAAyB,IAAI,OAAO,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAA,OAAO,EAAC,MAAM,CAAC;QAAA,WAAW,EAAC,MAAM,CAAA;KAAC,CAAC;IAS/F,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC3C,SAAS,EAAE,cAAc,EAAE,CAAC;IACnC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA0C;IACjF,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA8C;IACtF,0HAA0H;IACnH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IAGjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACpE,+FAA+F;IACxF,mBAAmB,IAAI,KAAK,CAAC,cAAc,GAAG,eAAe,CAAC;IAGrE,oGAAoG;IAC7F,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAiChE,aAAa,EAAE,cAAc,EAAE,CAAC;IAChC,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,IAAI,CAAC;IAChB,YAAY,EAAE,IAAI,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,UAAU,EAAE,kBAAkB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACI,mBAAmB,EAAE,OAAO,CAAS;IAC5C;;;;;OAKG;IACI,eAAe,EAAE,aAAa,GAAG,WAAW,CAAiB;IACpE,4DAA4D;IACrD,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,IAAI,CAAQ;IACtF;;;OAGG;IACI,eAAe,EAAE,OAAO,CAAS;IACxC;;;OAGG;IACI,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAQ;IACjD,oGAAoG;IAC7F,iBAAiB,EAAE,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAQ;IAG5F,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,eAAe,CAAU;IAGjC,OAAO,CAAC,cAAc,CAAqC;IAE3D,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,EAEvB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAGD,IAAI,UAAU,IAAI,SAAS,EAAE,EAAE,CAE9B;IAED,IAAI,yBAAyB,IAAI,MAAM,EAAE,CAExC;IAED,IAAI,YAAY,IAAI;QAAE,IAAI,CAAC,EAAE,YAAY,CAAC;QAAC,SAAS,CAAC,EAAE,YAAY,CAAA;KAAE,CAEpE;IAED;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAU5C;;;;;;;;;;;;;;;;;;MAkBE;gBAEA,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,KAAK,CAAC,cAAc,GAAG,eAAe,CAAC,EAClD,aAAa,EAAE,cAAc,EAAE,EAC/B,kBAAkB,EAAE,iBAAiB,EACrC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,wDAAwD;IACnG,cAAc,CAAC,EAAE,OAAO,EACxB,QAAQ,CAAC,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,EAAE,uDAAuD;IAC3E,eAAe,CAAC,EAAE,eAAe,EACjC,cAAc,CAAC,EAAE,cAAc;IAsFjC;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,oBAAoB;IAuBjF,cAAc,CAAC,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuT3H;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAczC;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAoB1C;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,kBAAkB,IAAI,MAAM,GAAG,SAAS;IAIxC;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM1C;;;;;;;;;;OAUG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAO9B;;;;OAIG;IACH,6BAA6B,IAAI,IAAI;IAkCrC,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAc5C,8BAA8B,IAAI,MAAM,EAAE;IAkB1C,sBAAsB,IAAI,OAAO;IAKjC,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQ1C,iBAAiB,IAAI,oBAAoB;IAEzC;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,oBAAoB;IAIlE,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAM/C,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAS5C,oBAAoB,IAAI,OAAO;IAI/B,oBAAoB,IAAI,IAAI;IAW5B,cAAc,IAAI,IAAI;IAWtB,gBAAgB,IAAI,IAAI;IAUxB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAQ5C,eAAe,IAAI,SAAS,EAAE;IAI9B,qBAAqB,IAAI,MAAM;IAI/B,mBAAmB,IAAI,SAAS;IAIhC,cAAc,IAAI,IAAI;IAItB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAI9C,mBAAmB,IAAI,SAAS;IAIhC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAI9D;;;OAGG;IACH,+BAA+B,IAAI,IAAI;IAmEvC;;;;;;OAMG;IACH,iBAAiB,IAAI,IAAI;IA+BzB;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG;IAgDtD;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmE9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAyB7B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IA+C/B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA+B9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsEzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4C3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAwC5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAmChC;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,GAAE,GAAQ,GAAG,GAAG;IAkHxC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAwE5B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2BhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAiC9B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IA2CnC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA6BhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAwB7B,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,sBAAsB;IAM9B,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,wBAAwB;IAShC,OAAO,CAAC,2BAA2B;CAKpC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -2246,10 +2246,16 @@ function retireUnsafeContinuation(engine, extraStacks = []) {
     const staleForm = Object.values(engine.cargo?.forms || {}).find(state => {
         const definition = engine.flowsMenu?.find(flow => flow.id === state.definition);
         const previous = previousRevisions[state.definition], current = definition?.safetyRevision;
-        return (previous !== undefined || current !== undefined) && previous !== current;
+        return (previous !== undefined || current !== undefined) && previous !== current
+            && !(definition?.safetyRevisionCompat !== undefined && previous === definition.safetyRevisionCompat);
     });
     const mismatch = frames.find(frame => {
         const current = engine.flowsMenu?.find(flow => flow.id === frame.flowId);
+        // A frame saved under the earlier fingerprint revision continues while its declaration is unchanged, under the new revision.
+        if (current?.safetyRevisionCompat !== undefined && frame.safetyRevision === current.safetyRevisionCompat) {
+            frame.safetyRevision = current.safetyRevision;
+            return false;
+        }
         return current?.safetyRevision !== undefined
             ? current.safetyRevision !== frame.safetyRevision
             : frame.safetyRevision !== undefined;

package/dist/runtime-identity.js

@@ -1 +1 @@
-export const JSFE_RUNTIME_FINGERPRINT = "sha256:fd2a9a936f409b3e5eaf40eb2c60a9f081caa099852cbd8fabdb5135a862d5f2";
+export const JSFE_RUNTIME_FINGERPRINT = "sha256:729d045d9d202f88024c65d732fa64fdcccd24bd0b4f85dd204698e3b3ccc91a";

package/docs/architecture-guide.md

@@ -0,0 +1,366 @@
+# JSFE flows architecture guide
+
+This guide is for developers new to JSFE. It explains the ideas behind the engine, the building blocks a flow set is
+made of, what the caller sees and hears, and how a conversation can feel free and natural while the transactions in it
+stay exact and safe. It introduces concepts; the [flow author reference](copilot-reference.md) is the precise
+specification, and the [README](../README.md) is the API reference.
+
+The examples use a fictional utility company. Every name and number in them is invented.
+
+## 1. The problem: two kinds of software in one conversation
+
+A caller who phones a utility might say any of these in one call:
+
+- "How much do I owe?"
+- "I want to pay 80 dollars with my card ending in 4242."
+- "Wait, make it 60."
+- "When is it due, by the way?"
+- "Actually, can I talk to a person?"
+
+Two very different kinds of software have to serve that call.
+
+**A conversational AI** understands people. It copes with any wording, any language, answers out of order, changes of
+mind and questions in the middle of a task. But it guesses, and a guess is never acceptable when money moves.
+
+**A transactional script** is exact. It verifies the caller, collects every required field, reads the amount back,
+asks for a clear YES and charges the card once. But a classic script is rigid: one question at a time, one expected
+answer, and anything else is "Sorry, I didn't understand."
+
+JSFE joins the two. **The flow owns the transaction; the AI helps only with understanding language, and every AI
+decision is a choice from a short closed list that the flow then checks.** The AI never writes a value into a
+payment, never confirms a charge and never decides what the business does.
+
+## 2. The big picture
+
+```mermaid
+flowchart LR
+   U([Caller: voice, SMS, chat]) --> H[Host application]
+   H -->|updateActivity| E[JSFE engine]
+   E -->|aiCallback: closed questions| AI[(Models: classifier and LLM)]
+   E -->|CALL-TOOL| T[(Business APIs)]
+   E -->|reply text, session| H
+   H -->|no flow serves the turn| G[Host AI answer: RAG, guru]
+```
+
+- **The host** is your application: it owns the channels (phone, text, web), credentials, storage, model
+  configuration and turn order. It calls `engine.updateActivity(...)` once per caller message and saves the session the
+  engine returns.
+- **The engine** runs flows. It decides whether the message belongs to a flow in progress, starts a new flow, or hands
+  the turn back to the host.
+- **Models** are reached only through the host's `aiCallback`. The engine builds every question it asks a model, and
+  decodes every answer, so a host never interprets a model's output itself.
+- **Tools** are the only way a flow touches the outside world (charge a card, send a text, open a ticket).
+- **The host's own AI** answers whatever no flow serves: a general question, small talk, a product question answered
+  from documents.
+
+## 3. Building blocks
+
+### Flow sets and tools
+
+A flow set is a JSON array of flow definitions (`tenant.flows`) with a matching JSON array of tool definitions
+(`tenant.tools`). A host usually composes several sets: the **system** set every tenant shares (identity checks, field
+collectors, retries, handoffs), optional product sets (for example a store integration), and the **tenant** set with
+that business's own flows. Flows reference each other by id, so a tenant set reuses shared workers instead of copying
+them.
+
+### Steps
+
+A flow is made of steps. Most authors need only a handful:
+
+| Step | What it does |
+| --- | --- |
+| `SAY` | Queue text for the caller. |
+| `SAY-GET` | Say the queued text and wait for the caller's answer. |
+| `SET` | Compute a value (a JavaScript expression) into a variable. |
+| `CASE` / `SWITCH` | Branch on a condition or a value. |
+| `FLOW` | Run another flow: `call` (and come back), `replace` or `reboot`. |
+| `CALL-TOOL` | Call a registered tool, with an `onFail` route. |
+| `END` | Finish this flow and return to the one that called it. |
+| `RETURN` | Finish every flow and hand a reply (or the turn) to the host. |
+| `DISPATCH` | Finish every flow and send this message to intent detection, as if it were the first message. |
+
+### The four authoring concepts
+
+Steps are the machine code. Authors mostly write **declarations**, and JSFE generates the steps.
+
+| Concept | You declare | JSFE gives you |
+| --- | --- | --- |
+| **Form** | the inputs a task needs | collection in any order, validation, corrections, resume after a detour |
+| **Provider** | the facts a flow can answer and where they come from | answers to exactly the fact asked, behind an identity gate |
+| **Performer** | an action: its effect, gate, tool, confirmation and outcomes | a guarded, confirmed, single execution |
+| **Worker** | a few explicit steps | a small reusable task (a calculation, a lookup, a handoff) |
+
+**Forms: any order, one question at a time.** A form lists its inputs once. The engine loops: find the first missing
+input, ask it, store whatever the answer actually contained, repeat. Because of that loop, a caller who says
+everything at once, answers a later question early, corrects an earlier answer, or comes back after a detour needs no
+special code:
+
+```json
+{
+  "declarationVersion": 2, "id": "pay-bill", "primary": true,
+  "description": "The caller wants to pay their bill now. Not: a question about a past payment.",
+  "form": {
+    "inputs": [
+      { "name": "account", "field": "account_number" },
+      { "name": "amount", "profile": { "kind": "amount", "min": 1, "money": { "currency": "USD", "cardinals": true, "intent": "payment" } },
+        "question": "How much would you like to pay?", "question_es": "¿Cuánto desea pagar?" },
+      { "name": "card", "form": "collect-credit-card" }
+    ]
+  }
+}
+```
+
+Forms nest: a payment form contains a card form, which contains card-number, expiration and security-code fields. An
+answer may fill an input of any active form in the chain, so "use the card ending in 4242" is understood while the
+payment is still asking for the amount.
+
+**Providers: answer what was asked.** A provider declares a catalog of facts (balance, due date, last payment), each
+with its source path, its wording and the identity gate that protects it. JSFE derives the rest from that one catalog:
+the `asked` parameter intent detection fills, the words that recognize each fact in the middle of another task, and the
+menu offered after an answer. "When is it due?" gets the due date, not a summary of the whole account.
+
+**Performers: actions with guard rails.** A performer is a form plus a declared action:
+
+```json
+"performs": [{
+  "action": "bill_payment", "effect": "charge", "subject": "form.data.account",
+  "gate": { "flow": "verify-caller", "verified": ["cargo.verified"] },
+  "flow": "payment-execute", "confirm": { "exact": true },
+  "outcomes": { "ok": "resolved", "failed": "unresolved", "unknown": "unresolved" }
+}]
+```
+
+From that, JSFE refuses to run the action without the gate, binds the confirmation to the exact request the caller
+heard, invalidates it when any input changes, and never treats a timeout as success.
+
+**An unknown result.** A timeout after the card may have been charged leaves the result unknown. The engine handles it
+for every action: the action is claimed once, a result that is not one of the declared `outcomes` counts as unknown,
+and an unknown charge or cancellation is held, never repeated (only a `send` may declare an explicit retry). Where the
+payment API accepts an idempotency key, the flow passes one as a tool argument as well.
+
+### Shared data and shared functions
+
+A value several flows use (a catalog, a list of services, a set of phrases) is written once in the set's data entry and
+referenced as `{"$data": "path.to.value"}`; expressions read it as `$data.name`. A function several flows use is
+written once in the set's functions entry and called as `fn.name(...)`. One source means two flows can never drift
+apart.
+
+### Session state
+
+The engine's session holds the flow stacks and `cargo`, the conversation's shared state. Form progress lives in
+`cargo.forms`, so a task interrupted by a question, a detour or a different request resumes from where it was when the
+caller comes back to it. The host stores the session between turns; the engine never stores anything itself.
+
+### Deploying while conversations are in progress
+
+A new flow set can go live while callers are in the middle of a flow. A flow's `version` decides what happens to them:
+
+- **A minor or patch change** (`1.4.0` to `1.5.0`: new wording, a new fact, a fix) keeps the conversation going on the
+  steps already saved in it.
+- **A breaking change bumps the major** (`1.5.0` to `2.0.0`): an input, entry argument or shared name removed or
+  renamed, or a value whose meaning changed. A conversation saved under the old major ends that task safely on its next
+  turn, without running any action or reading the caller's message as an answer, and the caller is asked to state the
+  request again.
+
+`continuationBreaks(previousFlows, nextFlows)` compares a set with the deployed one and lists every removed name that
+needs a major bump, so a forgotten bump fails the deploy instead of reaching a caller.
+
+## 4. One turn, step by step
+
+Every caller message travels the same path. The order is the design: **deterministic readers first, AI only where
+language is genuinely ambiguous, and the host last.**
+
+```mermaid
+flowchart TD
+   M[Caller message] --> A{Flow waiting for an answer?}
+   A -->|yes| R[Deterministic readers: keys, numbers, typed fields, exact phrases]
+   R -->|read| V[Validate, store, ask next question]
+   R -->|not read| K[Reply ranker: a closed choice]
+   K -->|answers / a choice| V
+   K -->|abort| X[End flows: request cancelled]
+   K -->|new_request| D[DISPATCH]
+   A -->|no| D
+   D --> S1[Intent detection, stage 1: which primary flow, or None]
+   S1 -->|a flow| S2[Stage 2: that flow's parameters]
+   S2 --> F[Start the flow; its form validates every value]
+   S1 -->|None| HA[Host answers with its own AI]
+```
+
+### Deterministic readers
+
+When a flow is waiting for an answer, the engine first tries to read it without any model: a keypad key, a phone number,
+an email, an amount, a card number, a whole-answer phrase of a choice. The rules are strict on purpose:
+
+- **The current question first.** An answer is read against the question being asked, and the inputs that question
+  explicitly invites ("type NEW CARD, LINK, or a different amount" invites an amount).
+- **Out of order needs the whole signature.** A number fills another field only when the whole number fits it: a
+  fragment of a longer number fills nothing.
+- **A confirmation is answered only when it is asked.** A stray "yes" never confirms anything that is not the current
+  question.
+- **One part of an answer never fills two fields.** Two fields of the same form that fit the same words are asked
+  about, never ranked.
+
+The engine records every out-of-order fill and every refused reading, so a host can log why a value was taken.
+
+### The reply ranker
+
+When the readers cannot read an answer that has words in it, the engine asks the **reply ranker** one question: what
+does this reply do with the question the flow asked? The model picks from a closed list:
+
+| Option | Meaning | What happens |
+| --- | --- | --- |
+| `answers` | the reply responds to the question | the flow continues; any value still goes through deterministic validation |
+| `choice:<key>` | the reply picks one of the question's offered choices | that choice is the answer |
+| `abort` | the caller withdraws the request | every flow ends; the caller hears that the request was cancelled |
+| `new_request` | the caller asks for something else | DISPATCH: the message goes to intent detection |
+
+Some options are **never offered**, so the ranker cannot pick them: a choice marked `exact` (anything that charges or
+cancels) and the YES of a firm confirmation. A ranker can understand "no thanks, maybe later" as NO; it can never
+produce a YES to a payment. Options that cost more when wrong need a higher score (a NO that would cancel what the
+caller was confirming, or a new request that leaves the question unanswered). A reply that clears no option is
+`answers`, and the question is asked again if nothing usable was in it.
+
+### DISPATCH
+
+`DISPATCH` is the bridge back to free conversation. It ends the flows in progress and re-reads the message through
+intent detection, in the same turn. If the message starts another flow, that flow starts; if not, the host answers it
+with its own AI and the conversation context. Form progress is kept in `cargo.forms`, so when the caller returns to
+the task ("OK, let's pay now"), the primary flow starts again and resumes from its saved draft instead of asking
+everything again.
+
+A flow can also ask a question whose answer is open ("Describe the problem") with a **contextual DISPATCH**
+(`onResponse: "continue"`): the ranker decides whether the reply answers, withdraws or changes the subject, and an
+answer's fields are extracted by the same parameter extraction intent detection uses.
+
+**DISPATCH is not giving up.** Sending a caller to a person (the `give-up` worker) happens only after real attempts at
+the answer ran out, or a service the flow needs failed. A caller who changed the subject is dispatched, never
+transferred.
+
+### Intent detection: two stages
+
+1. **Which flow.** Only primary flows can start this way, and stage 1 reads only their `description`: what should
+   start the flow and, in a `Not:` list, what belongs elsewhere. The answer is one flow or `None`.
+2. **Which arguments.** For the chosen flow only, stage 2 extracts its parameters: closed values (an enum such as
+   `asked: "balance"`, a boolean) and free text. A parameter the model cannot fill is left out, and the flow asks for
+   it.
+
+Each stage is one `aiCallback` call that carries instructions for both a classifier and an LLM, so a host can run
+either, or race both. JSFE builds both sets of instructions and decodes both answers (`jsfe/host`), which keeps a
+production host and a test harness on one implementation.
+
+## 5. Why the transactions stay safe
+
+The conversational freedom above never reaches the transaction directly. These are the guarantees, and where each one
+lives:
+
+| Guarantee | How |
+| --- | --- |
+| No private fact before identity is verified | a provider's `gate` and a performer's `gate` run the verification worker and check the verified paths |
+| No value accepted unchecked | every value, whether read, extracted at activation or understood by the ranker, passes the same field validator |
+| No charge without a clear YES | `confirm: { exact: true }`: only confirmation words or the option's exact phrases; never offered to the ranker |
+| The YES confirms what the caller heard | consent is bound to the request and the input revision; changing any input invalidates it |
+| "Yes, but make it 60" is not consent | an answer with YES plus a correction or another request is not approval of the old request |
+| No guessed success | an executor reports success, failure or unknown; unknown holds the action, it is never retried as if it failed |
+| One effect, once | effects run only through `CALL-TOOL`; the session records the attempt (`lastTurnToolCalls`) and the host never rolls such a turn back |
+| No escape from a half-finished effect | `must_complete` keeps a payment's card questions in place instead of dispatching an unreadable answer |
+
+The host keeps its side of the contract: one `updateActivity` at a time per conversation; a cancelled turn is awaited,
+not abandoned; a turn that attempted a tool is never restored to its earlier session; and external effects carry an
+idempotency key where the backend supports one. The [README](../README.md) section "Host Responsibilities: Tool Calls,
+Cancellation and Concurrency" explains each rule and the production incident behind it.
+
+## 6. What the caller sees and hears
+
+### Messages
+
+- **`SAY` and `SAY-GET`** carry `value` and a per-language variant (`value_es`); the session's language picks one.
+- **Voice and text differ.** A question may have written wording for text (`question_text`) and spoken wording for a
+  call. On a call, offer keys ("press 1 or say YES"); in text, never say "press".
+- **Spoken values.** Helpers read amounts, dates and last-four digits naturally on a call (`amountToSpeech`,
+  `dateToWords`, `last4`).
+
+### Questions and answers
+
+- **Choices.** A choice has a key, phrases in each language and, on a call, keypad keys. A key matches only as the
+  whole answer. Sensitive choices are `exact`.
+- **Confirmations.** `confirmation: "firm"` for consent (a charge, a cancellation, storing a card, filing a request):
+  only confirmation words. `"soft"` for an offer ("Would you like a link?"): the wider YES vocabulary.
+- **Proposals.** When the flow infers a value ("Is this the card ending in 4242?"), a proposal asks the caller to
+  approve that one value. It never authorizes the final action.
+- **Questions in the middle of a task.** "When is it due?" asked while paying is answered from the provider's catalog,
+  and the payment asks its question again.
+- **Menus after an answer.** A provider may offer a short menu ("To make a payment, say PAY. For a payment link, say
+  LINK."). Menu choices start their flows; "no thanks" ends politely.
+- **Misses.** The first unreadable answer is acknowledged and the question is asked again; validator rejections have
+  their own budget (`max_attempts`) with a declared recovery (`on_exhausted`). Every question also accepts a request
+  for a person.
+
+### Endings
+
+A flow ends with an outcome (`resolved`, `unresolved`, `deflected`, or `pending` for a task that was paused), and may
+give the host recovery guidance (`resume`, `restart`, `hold`, `none`). Hosts use these for reporting and for what to
+say when the conversation returns.
+
+## 7. A conversation, annotated
+
+```text
+Caller: Hi, I want to pay my bill.
+```
+Intent detection, stage 1, picks `PayBill`; stage 2 finds no amount. The form's first missing input is the account.
+
+```text
+Agent:  To make a payment, I first need to verify your account. Please say or enter your account number.
+Caller: 4417 2209
+Agent:  I found the account. Please enter the 6-digit code I just sent to your phone ending in 12.
+Caller: 381 552
+```
+Deterministic readers: the account number and the code are typed fields. The identity gate is now satisfied.
+
+```text
+Agent:  Your amount due is $84.20. How much would you like to pay?
+Caller: When is it due, actually?
+Agent:  Your payment is due on November 5. How much would you like to pay?
+```
+The question is a provider fact asked mid-form: answered, and the form asks its question again.
+
+```text
+Caller: Let's do 60 with the card ending in 4242.
+```
+One answer fills two fields: the amount (the current question) and the card (an input of the nested card form).
+
+```text
+Agent:  I'll charge $60.00 to the card ending in 4242. Say YES to pay, or NO.
+Caller: Yeah, but make it 70.
+```
+Not consent: YES plus a correction. The amount changes, the confirmation is invalidated, and the read-back is asked
+again for $70.00.
+
+```text
+Agent:  I'll charge $70.00 to the card ending in 4242. Say YES to pay, or NO.
+Caller: Yes.
+Agent:  Your payment of $70.00 was successful. Is there anything else I can help you with?
+Caller: Do you have energy-saving rebates?
+```
+An exact YES to the current confirmation runs the charge once. The last question is not something this flow reads:
+the ranker says `new_request`, DISPATCH sends it to intent detection, no flow serves it, and the host's own AI answers
+it from the company's documents.
+
+## 8. Design rules worth keeping
+
+1. **Declare, don't script.** Write the manifest (inputs, facts, actions) first; let JSFE generate the steps.
+2. **Support what the question invites, DISPATCH the rest.** Never build a natural-language interpreter for one field.
+3. **One source for everything.** Shared workers, shared data, shared functions: copies drift.
+4. **Flow behavior lives in flows.** Offers, prompts and wording belong to flow steps, not to the host. If a flow cannot
+   express something, it is a feature request for the engine.
+5. **Side effects only through `CALL-TOOL`,** with an `onFail` route and a declared answer for an unknown result.
+6. **Sensitive decisions are exact.** Any choice that charges or cancels is `exact`, and asked as a firm confirmation.
+7. **Descriptions are for detection only.** A primary's description says what starts it and what does not; caller
+   wording belongs in questions and fact renderers.
+8. **Test journeys, not just units.** Run the real engine on the real set: in order, out of order, all at once,
+   corrected, a mid-form question, a change of subject, a decline, voice and text, every language.
+
+## Where to read next
+
+- [Flow author reference](copilot-reference.md): every field, step, profile and rule, precisely.
+- [README](../README.md): engine API, `aiCallback`, intent detection, the reply ranker and host responsibilities.
+- [System flows](flows/system/README.md): the shared workers, a page and a chart per flow.

package/docs/copilot-reference.md

@@ -328,7 +328,6 @@ A Performer requires `form`, nonempty `performs`, `prepare` worker and `present`
 | `subject` | Ownership path such as `form.data.account` or `form.data.subject`; bind account/service identity, not an unrelated session flag. |
 | `gate:{flow?,verified:[paths]}` | Execution-time verification; rerun the declared flow before each fresh effect. |
 | `flow`, `tool` | Installed executor worker and/or registered tool identity. |
-| `idempotency`, `reconcile` | Explicit backend policy. Charge/write/send/cancel require at least one; declaring prose alone does not implement backend idempotency. |
 | `confirm:{exact:true}` | Required for charge, cancel or `reversible:false`. This requires a real form confirmation question. |
 | `outcomes` | Map declared executor statuses to business outcomes, including unknown results. |
 | `retry` | Explicit policies: `after:[knownStatuses]`; unknown retry only for SEND with `unknown:"explicit"` and a new accepted recovery choice. |
@@ -359,7 +358,6 @@ This reduced **composed-registry fragment** illustrates action authoring, not a
     "action":"curacao_payment", "effect":"charge", "subject":"form.data.account",
     "gate":{"flow":"get-account","verified":["cargo.otpVerified","cargo.authenticatedAccount"]},
     "flow":"payment-execute", "confirm":{"exact":true},
-    "reconcile":{"policy":"Hold unknown results for reconciliation; never automatically repeat a charge."},
     "outcomes":{"ok":"resolved","failed":"unresolved","unknown":"unresolved"}
   }],
   "prepare":"payment-prepare", "present":"payment-present",
@@ -378,7 +376,7 @@ This reduced **composed-registry fragment** illustrates action authoring, not a
 }
 ```
 
-The action key makes this session projection idempotent; it does not make the payment API idempotent. Declare backend `idempotency` only when the actual API supports the stated key/policy. Otherwise implement and test the declared reconciliation/unknown-result hold. Neither policy wording nor a recorded ledger entry proves a charge succeeded.
+The action key makes this session projection idempotent; it does not make the payment API idempotent. Where the API accepts an idempotency key, pass one as a tool argument. Either way an unknown result is held, never repeated: the engine claims each confirmed action once, treats a status outside `outcomes` as unknown, and never retries an unknown charge or cancellation. A recorded ledger entry does not prove a charge succeeded.
 
 ## 9. Outcomes, recovery and persistence
 
@@ -394,7 +392,7 @@ Session-only protects persisted, serialized session progress from reentry/repeti
 
 With a durable journal, the host saves the returned full session before acknowledging exact versioned action receipts with `checkpointActionSession`. Failed saves do not release scopes. Compatible late results project into current state without replaying presenters or restoring an old workflow merely because their storage sequence is larger. Recovery identity binds verified runtime bytes and actual flow/tool contracts; a version string alone is insufficient. Identity mismatch, unresolved effects or failed projections preserve holds. Do not change persistence mode for a live conversation or clear holds to manufacture compatibility.
 
-For versioned JSON, JSFE generates internal continuation revisions from the entire ordered declaration and named function bodies. Do not author `safetyRevision`. A source change retires obsolete unexecuted continuations before new input; uncertain effects remain preserved/quarantined. This is change detection, not authentication or automatic hot reload. Ordinary executable flows can explicitly use the SDK's revision helper when their host owns that policy.
+For versioned JSON, JSFE generates each declaration's continuation revision from its `version` major, plus the `version` major of each shared data or functions entry it uses (`$data`, `fn.`). Do not author `safetyRevision`. A minor or patch change keeps the revision: a saved session continues on its saved steps. **A change that can break a saved session bumps the major** (a removed or renamed input, entry argument, shared data or function name, or a changed meaning under the same name); the next turn of a session saved under the old major retires its unexecuted continuation before new input, and uncertain effects remain preserved/quarantined. `continuationBreaks(previousFlows, nextFlows)` (`jsfe/forms`) lists the removed names that need a major bump; run it against the deployed set before every deploy. A session saved under the earlier fingerprint revision (the whole declaration) continues while its declaration is unchanged. This is change detection, not authentication or automatic hot reload. Ordinary executable flows can explicitly use the SDK's revision helper when their host owns that policy.
 
 ## 10. Matching tools JSON
 

package/docs/development-release.md

@@ -87,7 +87,13 @@ group being read as another field (an account number, an amount).
 
 ## 1.9.2: address city list and part corrections
 
-The shared address form (`collect-geocoded-address`) asks the city when the ZIP code carries several place names (`geocode-zip` returns `localities`, Google's `postcode_localities`; at most 7): "Which city is it: Commerce, East Los Angeles, Los Angeles or Vernon?", by name or key. With one name it is not asked, and a caller who says the city is wrong is asked it plainly and any city is taken. At the read-back, naming one part without a value ("the city is wrong", "la ciudad no") asks only that part again, and a plain NO asks which part is wrong (zip code, city, street, apartment, or ALL to start over) instead of starting over. The part naming is an opt-in form confirmation setting, `confirm.named_fields: true`, read from each input's `names`; other forms keep their behavior. A host whose `geocode-zip` returns no `localities` keeps the one city it returns.
+The shared address form (`collect-geocoded-address`) asks the city when the ZIP code carries several place names (`geocode-zip` returns `localities`, Google's `postcode_localities`; at most 7): "Which city is it: Commerce, East Los Angeles, Los Angeles or Vernon?", by name or key. With one name it is not asked, and a caller who says the city is wrong is asked it plainly and any city is taken. At the read-back, naming one part without a value ("the city is wrong", "la ciudad no") asks only that part again, and a plain NO asks which part is wrong (zip code, city, street, apartment, or ALL to start over) instead of starting over. The part naming is an opt-in form confirmation setting, `confirm.named_fields: true`, read from each input's `names`; other forms keep their behavior. A host whose `geocode-zip` returns no `localities` keeps the one city it returns. A city read from the ZIP code alone is replaced by the city of an exact (rooftop) street match (90805: the ZIP lookup names Lakewood, its streets are Long Beach and Lakewood); a city the caller chose or gave is never replaced. With `named_fields`, a correction the word reader cannot read ("es Long Beach") goes to the reply ranker, which is offered each named part read back (`field:<input>`); a pick asks that part again, so the caller's value replaces the one read back.
+
+At the verification code question the reply ranker is offered `where`: a caller who asks where the code is ("¿dónde está?") hears where it went (by text to the cell ending with the last four digits, by email, or in this chat) and the code question again; nothing is sent again.
+
+The contact question's `intro` (why the account is needed) is not lost when the question is answered without being asked (the caller ID on file, a contact the caller gave): the first verification code question begins with it instead, once. A contact question that is asked says it, as before, and the code question does not repeat it.
+
+A form's or performer's `provides` catalog is validated like a provider's (`validateFlowContracts`: facts present, unique keys, a source path or worker for each fact, a gate for private facts, known gate and source workers), and every catalog's menu choices must name existing flows (a FLOW to an unknown name is skipped silently at run time). The check runs where flow sets are built and validated, never when an engine loads a set.
 
 ## 1.9.1: stored sessions without definition copies
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsfe",
-  "version": "1.15.9",
+  "version": "1.16.0",
   "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",
@@ -43,6 +43,7 @@
     "dist",
     "README.md",
     "LICENSE",
+    "docs/architecture-guide.md",
     "docs/copilot-reference.md",
     "docs/development-release.md"
   ],