jsfe 1.5.0 → 1.7.0

package/README.md

@@ -13,6 +13,8 @@ npm i jsfe
 - Comprehensive tutorials, examples, and best practices
 - **[README.md](README.md)** - Technical API reference (this document)
 - **[Flow author reference](docs/copilot-reference.md)** - the engine in one page, 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)
+- **[Native forms, providers and performers](docs/forms.md)** - owned reentrant collection, fact catalogs, confirmed effects and durable recovery
+- **[Development candidate acceptance](docs/development-release.md)** - reproducible package and cross-repository verification
 - **[System Flows](docs/system-flows.md)** and **[Shopify Flows](docs/shopify-flows.md)** - the bundled flow and tool libraries in `flows/`, step by step
 
 *For detailed tutorials, step-by-step examples, and comprehensive workflow patterns, see the **[User Guide](user-guide.md)**.*
@@ -342,6 +344,24 @@ const body = buildAiRequest(
   - `mergeTextParameters` adds a text model's free-text parameters only when the text model chose
     the same flow. The classifier's enum and boolean values always win.
 
+**Two-stage intent detection (opt-in: `engine.intentDetection = 'two-stage'`):**
+Stage 1 picks which PRIMARY flow, if any, the message starts, reading only each primary's `description`.
+Stage 2 extracts the selected flow's parameters, reading each parameter's name, type, `enum` and `description`,
+plus the flow's optional `parameterInstructions` (rules that span its parameters). A parameter marked
+`internal: true` is the flow's own and is never asked. Each stage is ONE aiCallback call: the positional
+arguments are the LLM instructions, and the 4th argument (`task: 'detect_flow'` with `stage: 1`, or
+`task: 'extract_parameters'` with `stage: 2`) carries both executors' instructions, `llm` and `systemOne`.
+The host runs either, or both as a hedge, and replies with the canonical JSON: `{ "flowName": … }` for
+stage 1, `{ "parameters": { … } }` for stage 2. `jsfe/host` exports `buildFlowStage`, `buildParameterStage`
+and the decoders (`decodeFlowLlm`, `decodeFlowSystemOne`, `decodeParametersLlm`, `decodeParametersSystemOne`,
+`isNearMiss`), so a host never interprets an answer itself. Only primaries are ever activated by detection;
+a stage-2 failure starts the flow without its parameters (it asks for them). The default, `'single-call'`,
+is the original single call.
+
+**Host start (`ContextEntry.start`):** `{ role: 'user', content, start: { flow, arguments } }` starts that
+flow (any flow, by id or name) with those arguments on this turn, without asking the AI. Only the host sets it;
+it is never derived from what the user typed.
+
 **Flow helpers — `jsfe/helpers`:**
 The functions the bundled system flows (`ask-choice`, `collect-input`, `authenticate-user`…) call from
 expressions, so every host runs the same ones. Pure: no credentials, no network. The engine does not
@@ -367,6 +387,12 @@ const engine = new WorkflowEngine(logger, aiCallback, flows, tools,
 - Session-aware helpers read only the cargo a caller passes: `callerTextNumber`, `textDestination`,
   `callerIsInternational`.
 
+`amountInAnswer` and `isAmountAnswer` retain their legacy parsing behavior. Explicit USD parsing uses
+`readMoneyAmount(text, {currency:'USD',cardinals:true,intent:'payment'})` or `isMoneyAmount` with the
+same options. `cardinals` defaults to false and `intent` is optional. FORM amount profiles opt in with
+`{kind:'amount',money:{currency:'USD',cardinals:true,intent:'payment'}}`; ordinary amount profiles retain
+legacy parsing. No currency conversion is inferred.
+
 **Alternative AI Services:**
 You can integrate any AI service (Claude, Gemini, local LLMs, etc.) by implementing this same interface. The engine only requires a function that takes system instructions and user input, then returns an AI response.
 
@@ -422,6 +448,14 @@ const flowsMenu = [
 - **`variables`** (optional): Flow-specific variable definitions with types and descriptions
 - **`version`** (optional): Flow version for compatibility tracking (defaults to "1.0")
 
+Mutable object defaults and authored step data are copied for each activation; changing one session's
+default data does not mutate a flow definition or another activation. This does not change the shared
+variable-container behavior above. A shared `FLOW` step with `callType:'replace'` preserves that container
+and does not initialize target defaults unless it declares `initializeDefaults:true`; that opt-in fills
+only undefined defaults before explicit parameters. Isolated replacement initializes its own scope.
+`SET` steps may declare `requireTrue:true` to throw `JSFERequiredSetFailed` unless their result is literal
+true; absent or false keeps ordinary SET behavior.
+
 ##### Primary vs. Sub-Flow Architecture
 
 The `primary` property enables a clean separation between:
@@ -738,10 +772,17 @@ return aiResponse;
 ### Host Responsibilities: Tool Calls, Cancellation and Concurrency
 
 A flow can take actions in the outside world through `CALL-TOOL` — charge a card, send an SMS,
-create a ticket. **The session returned by `updateActivity` is the only record that those steps
-already ran.** The engine cannot protect that record once it leaves `updateActivity`; the host
-owns it from there. Getting any of the rules below wrong lets a flow repeat an action the user
-asked for once.
+create a ticket. For ordinary `CALL-TOOL` flows, **the session returned by `updateActivity` records
+which steps already ran**; the host owns its persistence. Native performers can additionally use an
+explicitly attached durable action journal. Neither mode removes the host responsibilities below.
+Getting these rules wrong can repeat an action the user asked for once.
+
+The reference host defaults `config.jsfe` to `{durableActions:false,sessionEncoding:'plain'}`. Durable
+journaling and `sessionEncoding:'br-v1'` conversation writes are separate opt-ins. Encoded storage
+requires a reader-first rollout and a lossless conversion before an older-reader rollback. Durable
+recovery requires matching runtime/definition identities; a missing or different identity holds recovery
+without replaying effects or acknowledging receipts. See [development release boundaries](docs/development-release.md)
+for exact policy keys, storage limits and rollback requirements. Passing local tests does not approve deployment.
 
 This is not hypothetical. In production a caller confirmed a payment and repeated "confirm" a
 second later. The host cancelled the first turn while its charge was in flight and restored the

package/dist/forms/action-projection.d.ts

@@ -0,0 +1,4 @@
+export function validateActionProjection(steps: any, id?: string): any[];
+/** Compile both ordinary and late-result paths from exactly the same validated declaration. */
+export function actionProjectionExpression(steps: any, bindings: any): string;
+//# sourceMappingURL=action-projection.d.ts.map

package/dist/forms/action-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-projection.d.ts","sourceRoot":"","sources":["../../src/forms/action-projection.js"],"names":[],"mappings":"AAGA,yEAQC;AACD,+FAA+F;AAC/F,8EAKC"}

package/dist/forms/action-projection.js

@@ -0,0 +1,21 @@
+/** A performer projection updates current session facts only; it never orchestrates another flow or tool. */
+const LOCALS = ['form', 'formSnapshot', 'request', 'result', 'key'];
+const identifier = /^[A-Za-z_$][\w$]*$/;
+export function validateActionProjection(steps, id = 'performer') {
+    if (!Array.isArray(steps))
+        throw new Error(`Flow contract ${id}: project must be a SET-step array`);
+    for (const step of steps) {
+        if (!step || step.type !== 'SET' || step.onFail || step.branches || !identifier.test(step.variable || '') || LOCALS.concat(['cargo', 'arguments', 'eval']).includes(step.variable) || step.value === undefined)
+            throw new Error(`Flow contract ${id}: project permits only SET expressions with local temporary variables`);
+        if (typeof step.value === 'string' && step.value.includes('{{'))
+            throw new Error(`Flow contract ${id}: project uses expressions, not message templates`);
+    }
+    return steps;
+}
+/** Compile both ordinary and late-result paths from exactly the same validated declaration. */
+export function actionProjectionExpression(steps, bindings) {
+    validateActionProjection(steps);
+    const variables = [...new Set(steps.map(step => step.variable))];
+    const expressions = steps.map(step => `${step.variable}=(${typeof step.value === 'string' ? step.value : JSON.stringify(step.value)});`).join('\n');
+    return `(function(${LOCALS.join(',')}){${variables.length ? 'var ' + variables.join(',') + ';' : ''}${expressions}return true;})(${LOCALS.map(name => bindings[name]).join(',')})`;
+}

package/dist/forms/action-recovery.d.ts

@@ -0,0 +1,12 @@
+export function resumableActionSession(session: any, flows: any, identity: any): any;
+/** Mutate the supplied session so the host retains its original object reference. */
+export function restoreActionSession(session: any, recovery: any, contextEntry: any, identity: any): any;
+/** Update only the exact action identity; later requests and draft values remain owned by their current task. */
+export function reconcileRecoveredAction(cargo: any, key: any, result: any): boolean;
+/**
+ * Recover a late result against CURRENT cargo. Only its effect-free projector runs: no
+ * original presenter, caller continuation, confirmation, or nested performer is replayed.
+ * The engine must restore the returned suspended stacks in a finally block after playing.
+ */
+export function projectActionRecoverySession(session: any, recovery: any, contextEntry: any, flows: any, identity: any): any;
+//# sourceMappingURL=action-recovery.d.ts.map

package/dist/forms/action-recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-recovery.d.ts","sourceRoot":"","sources":["../../src/forms/action-recovery.js"],"names":[],"mappings":"AAKA,qFAuBC;AAOD,qFAAqF;AACrF,yGAQC;AACD,iHAAiH;AACjH,qFAMC;AACD;;;;GAIG;AACH,6HAkCC"}

package/dist/forms/action-recovery.js

@@ -0,0 +1,125 @@
+/** Durable resume snapshots contain engine data only, never a live engine or transport. */
+import { applyRecoveryStatePolicy } from '../host/recovery-policy.js';
+import { assertActionRecoveryIdentity, actionRecoveryIdentityMatches } from '../host/recovery-identity.js';
+import { actionProjectionExpression, validateActionProjection } from './action-projection.js';
+const clone = value => JSON.parse(JSON.stringify(value));
+export function resumableActionSession(session, flows, identity) {
+    if (!session)
+        throw new Error('Action journal requires an active engine session');
+    const recoveryIdentity = assertActionRecoveryIdentity(identity);
+    const snapshot = clone(session);
+    snapshot.actionRecoveryIdentity = recoveryIdentity;
+    let owner;
+    for (let s = snapshot.flowStacks.length - 1; s >= 0 && !owner; s--) {
+        const frames = snapshot.flowStacks[s];
+        for (let f = frames.length - 1; f >= 0; f--) {
+            if (frames[f].flowId === 'perform-action') {
+                owner = { s, f, frame: frames[f] };
+                break;
+            }
+        }
+    }
+    const definition = flows.find(flow => flow.id === 'perform-action');
+    if (!owner || !definition)
+        throw new Error('Durable action ports require the shared perform-action worker');
+    snapshot.flowStacks.length = owner.s + 1;
+    snapshot.flowStacks[owner.s].length = owner.f + 1;
+    owner.frame.flowStepsStack = clone(definition.steps).reverse();
+    owner.frame.inputStack = [];
+    delete owner.frame.pendingVariable;
+    delete owner.frame.pendingInterruption;
+    // Earlier completed actions in this turn may still have unsent messages.
+    snapshot.response = null;
+    return snapshot;
+}
+function matchingSnapshot(session, recovery, identity) {
+    const snapshot = recovery?.session;
+    if (!snapshot || snapshot.sessionId !== session.sessionId || snapshot.userId !== session.userId)
+        throw new Error('Durable action checkpoint belongs to a different session');
+    if (!actionRecoveryIdentityMatches(identity, snapshot.actionRecoveryIdentity))
+        throw new Error('Durable action checkpoint requires a compatible runtime and flow contract');
+    return snapshot;
+}
+/** Mutate the supplied session so the host retains its original object reference. */
+export function restoreActionSession(session, recovery, contextEntry, identity) {
+    const restored = clone(matchingSnapshot(session, recovery, identity));
+    applyRecoveryStatePolicy(restored, session);
+    for (const key of Object.keys(session))
+        delete session[key];
+    Object.assign(session, restored);
+    session.cargo ||= {};
+    session.lastTurnRecovery = { key: recovery.key, sequence: recovery.sequence, deferredInput: contextEntry };
+    return session;
+}
+/** Update only the exact action identity; later requests and draft values remain owned by their current task. */
+export function reconcileRecoveredAction(cargo, key, result) {
+    const matches = record => record && (record.durableKey || record.key) === key;
+    const update = record => { if (matches(record)) {
+        record.result = JSON.parse(JSON.stringify(result));
+        record.status = result.status === 'unknown' ? 'unknown' : 'completed';
+    } };
+    for (const state of Object.values(cargo.forms || {})) {
+        for (const record of Object.values(state.actions || {}))
+            update(record);
+        update(state.proposal);
+    }
+    for (const [localKey, record] of Object.entries(cargo.actionJournal || {}))
+        if (matches(record)) {
+            update(record);
+            if (record.status === 'completed')
+                delete cargo.actionJournal[localKey];
+        }
+    return true;
+}
+/**
+ * Recover a late result against CURRENT cargo. Only its effect-free projector runs: no
+ * original presenter, caller continuation, confirmation, or nested performer is replayed.
+ * The engine must restore the returned suspended stacks in a finally block after playing.
+ */
+export function projectActionRecoverySession(session, recovery, contextEntry, flows, identity) {
+    const snapshot = matchingSnapshot(session, recovery, identity), record = recovery.record;
+    if (!record || record.key !== recovery.key || record.sequence !== recovery.sequence)
+        throw new Error('Late action recovery requires its exact durable record');
+    const frames = snapshot.flowStacks.flat().filter(Boolean), actionIndex = frames.findLastIndex(frame => frame.flowId === 'perform-action');
+    const registry = new Map(flows.map(flow => [flow.id, flow]));
+    let owner, definition;
+    for (let i = actionIndex - 1; i >= 0; i--) {
+        const candidate = registry.get(frames[i].flowId);
+        if (candidate?.variables?.contract?.value?.role === 'performer') {
+            owner = frames[i];
+            definition = candidate;
+            break;
+        }
+    }
+    if (!owner || !definition)
+        throw new Error('Late action recovery requires an owning declarative performer');
+    const project = definition.variables?.[definition.variables.contract.value.projects || 'projection']?.value || [];
+    validateActionProjection(project, definition.id);
+    const variables = owner.variables || {}, form = variables.form_instance;
+    const formSnapshot = snapshot.cargo?.forms?.[form];
+    if (!formSnapshot)
+        throw new Error('Late action recovery is missing its owned form snapshot');
+    const frame = clone(owner), result = clone(record.result || { status: 'unknown', reason: 'result_pending' });
+    frame.variables = { ...frame.variables, pf_recovery_form: clone(formSnapshot), pf_recovery_request: clone(variables.pf_request || frames[actionIndex]?.variables?.request || {}), pf_recovery_result: result, pf_recovery_key: record.key,
+        pf_recovery_receipt: { key: record.key, sequence: record.sequence, attemptId: record.attemptId, scopeId: record.scopeId, signature: record.signature } };
+    const set = (id, variable, value) => ({ id, type: 'SET', variable, value, requireTrue: true });
+    const notice = result.status === 'unknown'
+        ? { en: 'I still could not confirm whether your earlier request completed. I have not repeated it.', es: 'Todavía no pude confirmar si su solicitud anterior se completó. No la he repetido.' }
+        : ['refused', 'failed', 'invalid_email'].includes(result.status)
+            ? { en: 'Your earlier request did not complete.', es: 'Su solicitud anterior no se completó.' }
+            : { en: 'I recovered a result for your earlier request.', es: 'Recuperé un resultado de su solicitud anterior.' };
+    frame.flowStepsStack = [
+        set('recovery_project', 'pf_projected', actionProjectionExpression(project, { form: 'form_instance', formSnapshot: 'pf_recovery_form', request: 'pf_recovery_request', result: 'pf_recovery_result', key: 'pf_recovery_key' })),
+        set('recovery_reconcile', 'noop', `(${reconcileRecoveredAction.toString()})(cargo,pf_recovery_key,pf_recovery_result)`),
+        set('recovery_receipt', 'noop', 'consumeActionReceipt(cargo,pf_recovery_receipt)'),
+        { id: 'recovery_notice', type: 'SAY', value: notice.en, value_es: notice.es },
+    ].reverse();
+    frame.inputStack = [];
+    frame.contextStack = [];
+    for (const key of ['pendingVariable', 'pendingVariableContext', 'pendingVariableAsSpoken', 'pendingInterruption'])
+        delete frame[key];
+    const suspendedStacks = session.flowStacks;
+    session.flowStacks = [[frame]];
+    session.lastTurnRecovery = { key: record.key, sequence: record.sequence, deferredInput: contextEntry, projection: true };
+    return suspendedStacks;
+}

package/dist/forms/action-tools.d.ts

@@ -0,0 +1,29 @@
+/** Internal transport ports. Registered by WorkflowEngine; no network implementation lives in JSFE. */
+export const ACTION_TOOLS: {
+    id: string;
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            outcome?: {
+                type: string[];
+            } | undefined;
+            record: {
+                type: string;
+            };
+            action: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    implementation: {
+        type: string;
+        function: string;
+        retries: number;
+        timeout: number;
+    };
+}[];
+//# sourceMappingURL=action-tools.d.ts.map

package/dist/forms/action-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-tools.d.ts","sourceRoot":"","sources":["../../src/forms/action-tools.js"],"names":[],"mappings":"AAAA,uGAAuG;AACvG;;;;;;;;;;;;;;;;;;;;;;;;;;IAII"}

package/dist/forms/action-tools.js

@@ -0,0 +1,6 @@
+/** Internal transport ports. Registered by WorkflowEngine; no network implementation lives in JSFE. */
+export const ACTION_TOOLS = ['claim', 'complete'].map(operation => ({
+    id: `jsfe:action-${operation}`, name: `JSFE action ${operation}`, description: `Await the configured durable action journal ${operation} port.`,
+    parameters: { type: 'object', properties: { record: { type: 'object' }, action: { type: 'object' }, ...(operation === 'complete' ? { outcome: { type: ['object', 'null'] } } : {}) }, required: ['record', 'action'], additionalProperties: false },
+    implementation: { type: 'local', function: operation === 'claim' ? 'jsfeClaimAction' : 'jsfeCompleteAction', retries: 0, timeout: 10000 },
+}));

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

@@ -0,0 +1,2 @@
+export const FLOWS: any[];
+//# sourceMappingURL=address-flows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"address-flows.d.ts","sourceRoot":"","sources":["../../src/forms/address-flows.js"],"names":[],"mappings":"AAsCA,0BAAwE"}

package/dist/forms/address-flows.js

@@ -0,0 +1,39 @@
+/** Shared geocoded mailing-address collector over host-provided geocode tools. */
+import { defineForm, defineWorker } from './contracts.js';
+import { addressDraft, zipLocation, streetLocation, resolvedAddress } from '../helpers/address.js';
+const S = (id, variable, value) => ({ id, type: 'SET', variable, value });
+const F = (id, value, parameters = {}, callType = 'call') => ({ id, type: 'FLOW', value, parameters, callType });
+const W = (id, condition, step) => ({ id, type: 'CASE', branches: { ['condition: ' + condition]: step, default: S(id + '_skip', 'noop', 'true') } });
+const V = o => Object.fromEntries(Object.entries(o).map(([k, v]) => [k, { type: Array.isArray(v) ? 'array' : v === null || typeof v === 'object' ? 'object' : typeof v, value: v }]));
+const E = (fn, ...args) => `(${fn.toString()})(${args.join(',')})`;
+const P = (name, type = 'string') => ({ name, type, description: name });
+const C = (id, summary, steps, extra = {}) => defineWorker({ id, name: id.split('-').map(w => w[0].toUpperCase() + w.slice(1)).join(''), description: summary, ...extra, contract: { role: 'worker', summary, ...extra.contract }, steps });
+const streetPattern = '\\b\\d{1,6}\\s+(?:[A-Za-z0-9.\\xC0-\\xFF-]+\\s+){1,8}(?:st(?:reet)?|ave(?:nue)?|blvd|boulevard|rd|road|ln|lane|dr(?:ive)?|way|ct|court|pl(?:ace)?|pkwy|parkway|cir(?:cle)?|ter(?:race)?)\\b';
+const address = defineForm({ id: 'collect-geocoded-address', name: 'CollectGeocodedAddress', version: '1.0.0', description: 'Collect a mailing address in any order, project geocoder evidence, and read the complete address back for confirmation.', contract: { summary: 'Collect and confirm a geocoded mailing address', result: { path: 'form result.resolved', type: 'object' } }, parameters: [P('given')], extraVars: { given: '', zip: '', street: '', unit: '', draft: null, address_result: null, exit_context: 'your address', exit_context_es: 'su dirección' },
+    before: [S('address_given', 'given', "given || (cargo.forms[cargo.forms[form_instance].parent] || {}).context && (cargo.forms[cargo.forms[form_instance].parent].context.given || '') || ''"), S('address_draft', 'draft', E(addressDraft, "given || (cargo.forms[form_instance].seeds && cargo.forms[form_instance].seeds.given) || ''")), S('address_seed_zip', 'zip', "zip || draft.zip"), S('address_seed_street', 'street', "street || draft.street"), S('address_seed_unit', 'unit', "unit || draft.unit"), S('address_data', 'noop', "(cargo.forms[form_instance].data=Object.assign({need_city:false},cargo.forms[form_instance].data || {}), draft.street ? (cargo.addressDraft={said:draft.street}) : null, true)")],
+    inputs: [{ name: 'zip', field: 'zip', validator: 'address-zip-validate', prepare: 'address-zip-prompt', question_from: 'zip_question', question: 'What is the 5-digit zip code of your new address?', question_es: '¿Cuál es el código postal de 5 dígitos de su nueva dirección?' },
+        { name: 'city_state', label: 'city and state', label_es: 'ciudad y estado', profile: { kind: 'text' }, when: { 'form.data.need_city': true }, depends_on: ['zip'], question: 'What city and state is that in?', question_es: '¿En qué ciudad y estado está?' },
+        { name: 'street', label: 'street address', label_es: 'dirección', profile: { kind: 'pattern', regex: streetPattern, accept_other: true }, depends_on: ['zip'], validator: 'address-street-validate', prepare: 'address-street-prompt', question_from: 'street_question', question: 'What is the street address?', question_es: '¿Cuál es la dirección?' },
+        { name: 'unit', reset_on: ['street'], label: 'apartment or unit', label_es: 'apartamento o unidad', profile: { kind: 'pattern', regex: '(?:\\bapt\\.?|\\bunit|#)\\s*([\\w-]+)', group: 1, accept_other: true }, question: 'Is there an apartment or unit number? Type the number, or NONE.', question_es: '¿Hay un número de apartamento o unidad? Escriba el número, o NINGUNO.' }],
+    before_confirm: [S('address_resolved', 'address_result', E(resolvedAddress, 'cargo.forms[form_instance].values', 'cargo.forms[form_instance].data'))],
+    confirm: { no_keys: ['2', 'not right', 'not correct', 'incorrect', 'wrong', 'no es correcto', 'no es correcta', 'incorrecta'], question: 'Your new address is {{address_result.line}}. Is that correct?', question_es: 'Su nueva dirección es {{address_result.line}}. ¿Es correcta?' },
+    after: [S('address_result_store', 'noop', '(cargo.forms[form_instance].values.resolved = address_result, cargo.address = address_result, cargo.addressDraft = null, true)')], declined: [S('address_retry_noop', 'noop', 'true')] });
+const zip = C('address-zip-validate', 'Read city and state from geocoder evidence for the proposed ZIP; missing geocoder data requires an explicit city.', [
+    S('address_zip_components', 'components', "'postal_code:'+value+'|country:US'"), { id: 'address_zip_tool', type: 'CALL-TOOL', tool: 'geocode-zip', variable: 'result', args: { components: '{{components}}', address: '' }, onFail: S('address_zip_failed', 'result', 'null') },
+    S('address_zip_location', 'location', E(zipLocation, 'result')),
+    S('address_zip_result', 'noop', "(cargo.forms[form].data=Object.assign({},cargo.forms[form].data,{location:location,need_city:!location}), cargo.inputCheck={ok:true,value:String(value)}, true)")
+], { parameters: [P('form'), P('value')], variables: V({ components: '', result: null, location: null }), contract: { tools: ['geocode-zip'], result: { path: 'cargo.inputCheck', type: 'object' } } });
+const street = C('address-street-validate', 'Validate a proposed street against its ZIP; retain unverified wording when geocoding is inconclusive.', [
+    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)")
+], { 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].data.location.line+'. ':'')+'What is the street address?',cargo.forms[form].data.street_question_es=(cargo.forms[form].data.location?'Entendido, '+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' } } });
+const declined = C('collect-geocoded-address-declined', 'Start a fresh address pass when the complete address is declined.', [
+    S('address_retry_owner', 'parent_form', 'cargo.forms[form_instance].parent'), S('address_retry_input', 'result_input', 'cargo.forms[form_instance].result_input'),
+    S('address_retry_clear', 'noop', "(resetFormInputs(cargo,form_instance,['zip','city_state','street','unit']),cargo.forms[form_instance].data={retry:true,need_city:false},true)"),
+    F('address_retry', 'collect-geocoded-address', { form_instance: '{{form_instance}}', parent_form: '{{parent_form}}', result_input: '{{result_input}}' }, 'replace')
+], { parameters: [P('form_instance')], variables: V({ parent_form: '', result_input: '' }) });
+export const FLOWS = [address, zip, street, zipPrompt, streetPrompt, declined];