@enricai/barnacle 1.12.79 → 1.12.81

package/dist/scripts/recon-generate.js

@@ -22,6 +22,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveStepPayloadField = resolveStepPayloadField;
+exports.canonicalPayloadField = canonicalPayloadField;
 exports.buildKnownFieldValues = buildKnownFieldValues;
 exports.extractStepPersonaValue = extractStepPersonaValue;
 exports.extractNavigateToHashFragmentValue = extractNavigateToHashFragmentValue;
@@ -68,6 +69,7 @@ exports.resolveRecurringNavigateToFacets = resolveRecurringNavigateToFacets;
 exports.emitMultiStepExecuteHttp = emitMultiStepExecuteHttp;
 exports.countSpliceableFacets = countSpliceableFacets;
 exports.spliceFacetsIntoStringVariable = spliceFacetsIntoStringVariable;
+exports.matchFacetRecurrence = matchFacetRecurrence;
 exports.spliceFacetsIntoArrayVariable = spliceFacetsIntoArrayVariable;
 exports.renderGqlVariablesExpr = renderGqlVariablesExpr;
 exports.findAllObjectArrayFields = findAllObjectArrayFields;
@@ -88,9 +90,13 @@ exports.resetFoldPlanResolutionCallCountForTests = resetFoldPlanResolutionCallCo
 exports.resolveFoldPlan = resolveFoldPlan;
 exports.resolveApplicableFoldPlans = resolveApplicableFoldPlans;
 exports.buildContractChecklist = buildContractChecklist;
+exports.contractUsesApplicantContactSchema = contractUsesApplicantContactSchema;
 exports.emitContractTs = emitContractTs;
 exports.unreferencedRequiredUrlFields = unreferencedRequiredUrlFields;
 exports.assertRequiredUrlFieldsReferenced = assertRequiredUrlFieldsReferenced;
+exports.unreferencedDeclaredPayloadFields = unreferencedDeclaredPayloadFields;
+exports.unreadPayloadFieldChecklistLines = unreadPayloadFieldChecklistLines;
+exports.buildStepInstructionExpr = buildStepInstructionExpr;
 exports.emitConfigManifest = emitConfigManifest;
 exports.emitBrowserFlowTs = emitBrowserFlowTs;
 exports.emitIndexTs = emitIndexTs;
@@ -109,6 +115,8 @@ const load_value_constraints_1 = require("../recon/load-value-constraints");
 const load_vocabulary_1 = require("../recon/load-vocabulary");
 const value_constraints_1 = require("../recon/value-constraints");
 const vocabulary_1 = require("../recon/vocabulary");
+const flow_runner_1 = require("../scraper/flow-runner");
+const quoted_spans_1 = require("../scraper/quoted-spans");
 const recon_shared_1 = require("./recon-shared");
 const logger = (0, logging_1.getScriptLogger)("recon-generate");
 /**
@@ -141,39 +149,54 @@ const RESERVED_ENV_TOKEN = /\$\{RECON_[A-Z0-9_]*\}/;
  * (never through) vocabulary/payload-field resolution.
  */
 const RECON_PASSWORD_TOKEN = `$${"{RECON_PASSWORD}"}`;
-/**
- * Masks the apostrophe in a possessive `'s` (e.g. "the candidate's name") with
- * a non-quote placeholder of the same length, so a naive `'...'` quote scan
- * doesn't mistake the possessive apostrophe for an opening quote delimiter.
- * Length-preserving so callers that need positions in the ORIGINAL instruction
- * can reuse the indices matched against the masked string unchanged.
- */
-function maskPossessiveApostrophes(instruction) {
-    return instruction.replace(/(\w)'(s\b)/g, "$1 $2");
-}
-function findQuoteSpans(instruction) {
-    const masked = maskPossessiveApostrophes(instruction);
-    return [...masked.matchAll(/'([^']*)'/g)].map((m) => ({
-        index: m.index,
-        length: m[0].length,
-        value: instruction.slice(m.index + 1, m.index + m[0].length - 1),
+const DOUBLE_QUOTED_SPAN = /"([^"]+)"/g;
+/**
+ * Quoted spans of a flow-step instruction. The runtime parsers only understand
+ * single quotes, so a double-quoted span is consulted only when the step has no
+ * single-quoted one — a mixed instruction keeps its single-quote grammar, and a
+ * double-quoted-only step still has a spliceable value instead of being skipped.
+ */
+function findInstructionSpans(instruction) {
+    const single = (0, quoted_spans_1.findQuotedSpans)(instruction);
+    if (single.length > 0)
+        return single;
+    return Array.from(instruction.matchAll(DOUBLE_QUOTED_SPAN), (match) => ({
+        text: match[1] ?? "",
+        start: match.index ?? 0,
+        end: (match.index ?? 0) + match[0].length,
     }));
 }
+/**
+ * A quoted span that names the widget or question a step targets rather than
+ * the value it carries: followed by a widget noun ("'State' prompt selector"),
+ * or introduced by "for"/"from" ("for the 'State' question").
+ */
+function namesAWidgetLabel(instruction, span) {
+    const before = instruction.slice(Math.max(0, span.start - 25), span.start);
+    const after = instruction.slice(span.end);
+    return (/^\s*(?:prompt\s+selector|selector|dropdown|drop-down|multiselect|typeahead|field|question|list|menu|widget)\b/i.test(after) || /\b(?:for|from)(?:\s+the)?(?:\s+(?:question|answer))?\s*$/i.test(before));
+}
 /**
  * Picks which quoted span in an instruction is the persona VALUE, per the
  * grammar recon-flow steps use: a `Select`/`Choose`/`Pick` step names the
- * ANSWER first, then the question, so the value is the FIRST quoted span; a
- * `Fill`/`Enter`/`Type` step names the field label first and the value last,
- * so it is the LAST quoted span.
+ * ANSWER after the verb (wherever the verb sits, so a leading context phrase
+ * does not hide it), so the value is the first span following the verb that is
+ * not a widget label — "choose the 'State' field, then choose 'Texas'" must
+ * yield Texas, not the label. Any other step (`Fill`/`Enter`/`Type`) names the
+ * field label first and the value last, so it is the LAST quoted span.
  */
 function pickValueSpan(instruction, spans) {
-    return /^\s*(select|choose|pick)\b/i.test(instruction) ? spans[0] : spans[spans.length - 1];
+    const verb = /\b(select|choose|pick)\b/i.exec(instruction);
+    const afterVerb = verb ? spans.filter((span) => span.start >= verb.index + verb[0].length) : [];
+    const answer = afterVerb.find((span) => !namesAWidgetLabel(instruction, span)) ?? afterVerb[0];
+    return answer ?? spans[spans.length - 1];
 }
 /**
  * Locates the splice site in a flow-step instruction as `{ before, matched,
  * after }` slices of the ORIGINAL instruction — a reserved `${RECON_*}` env
  * token when present (preferred, since it names its own site unambiguously),
- * otherwise the quoted VALUE span per {@link pickValueSpan}'s verb-class rule.
+ * otherwise the quoted VALUE span per {@link pickValueSpan}'s verb-class rule
+ * (its quote delimiters stay in `before`/`after`, so a splice remains quoted).
  * This is the position-aware counterpart to {@link extractStepPersonaValue}:
  * that function only needs the extracted string, this one needs the actual
  * before/after slices so a template literal can be rebuilt around the site.
@@ -189,14 +212,14 @@ function locateSpliceSite(instruction) {
             after: instruction.slice(envToken.index + envToken[0].length),
         };
     }
-    const spans = findQuoteSpans(instruction);
+    const spans = findInstructionSpans(instruction);
     if (spans.length === 0)
         return null;
     const span = pickValueSpan(instruction, spans);
     return {
-        before: instruction.slice(0, span.index),
-        matched: instruction.slice(span.index, span.index + span.length),
-        after: instruction.slice(span.index + span.length),
+        before: instruction.slice(0, span.start + 1),
+        matched: instruction.slice(span.start + 1, span.end - 1),
+        after: instruction.slice(span.end - 1),
     };
 }
 /**
@@ -207,15 +230,15 @@ function locateSpliceSite(instruction) {
  * can never be mistaken for the data it merely mentions.
  */
 function namesAControl(instruction) {
-    return findQuoteSpans(instruction).some((span) => /^\s*(button|link|tab)\b/i.test(instruction.slice(span.index + span.length)));
+    return findInstructionSpans(instruction).some((span) => /^\s*(button|link|tab)\b/i.test(instruction.slice(span.end)));
 }
 /** The quoted VALUE a Select/Choose/Fill step carries, per {@link pickValueSpan}'s
  * grammar rule — used to validate a vocabulary match's ANSWER, not just its label. */
 function pickedQuotedValue(instruction) {
-    const spans = findQuoteSpans(instruction);
+    const spans = findInstructionSpans(instruction);
     if (spans.length === 0)
         return null;
-    const value = pickValueSpan(instruction, spans).value;
+    const value = pickValueSpan(instruction, spans).text;
     return value.length > 0 ? value : null;
 }
 /**
@@ -254,9 +277,12 @@ function toPascalCase(siteId) {
  *   label match names, or it is not that field's datum (e.g. a device-type
  *   dropdown's `'Mobile'` looks like a phone-number field by label alone, but
  *   is nothing like the number the Fill step already bound).
+ * @param canonicalise map a vocabulary row's name onto the equivalent
+ *   `ApplicantContactSchema` key ({@link canonicalPayloadField}); set by the
+ *   job-application emit paths whose contract extends that base schema
  * @returns the PascalCase payload field name to splice, or null to keep literal
  */
-function resolveStepPayloadField(instruction, explicit, forceNone, vocabulary = vocabulary_1.EMPTY_VOCABULARY, knownFieldValues = EMPTY_KNOWN_FIELD_VALUES) {
+function resolveStepPayloadField(instruction, explicit, forceNone, vocabulary = vocabulary_1.EMPTY_VOCABULARY, knownFieldValues = EMPTY_KNOWN_FIELD_VALUES, canonicalise = false) {
     if (forceNone)
         return null;
     if (explicit)
@@ -267,7 +293,7 @@ function resolveStepPayloadField(instruction, explicit, forceNone, vocabulary =
         return null;
     // A quoted literal or a reserved ${RECON_*} env token IS the recon constant
     // this step would replace, so it is spliceable on its own.
-    const hasQuotedConstant = /'[^']*'/.test(instruction) || RESERVED_ENV_TOKEN.test(instruction);
+    const hasQuotedConstant = findInstructionSpans(instruction).length > 0 || RESERVED_ENV_TOKEN.test(instruction);
     // A dropdown step carries no constant to replace, so a label match alone can't
     // tell "select the test candidate's state" (the caller's data) from "select the
     // neighborhood from the Country dropdown" (a facet that merely says Country).
@@ -286,18 +312,49 @@ function resolveStepPayloadField(instruction, explicit, forceNone, vocabulary =
     for (const [rx, field] of vocabulary.table) {
         if (!rx.test(instruction))
             continue;
+        const resolved = canonicalise ? canonicalPayloadField(field) : field;
         if (!isSelectStep)
-            return field;
+            return resolved;
         const answer = pickedQuotedValue(instruction);
         if (answer !== null && OPERATIONAL_ANSWER.test(answer.trim()))
             return null;
-        const known = knownFieldValues.get(field);
+        const known = knownFieldValues.get(resolved);
         if (known !== undefined && answer !== known)
             return null;
-        return field;
+        return resolved;
     }
     return null;
 }
+/**
+ * Maps a vocabulary row's field name onto the base schema's equivalent so a
+ * consumer's `MobilePhone` does not become an extra required key beside
+ * `Phone`. Names the base schema has no equivalent for pass through.
+ */
+function canonicalPayloadField(field) {
+    if (applicantContactFieldNames.has(field) || baseContractFieldNames.has(field))
+        return field;
+    const canonical = (0, ats_field_vocabulary_1.resolveCanonicalAtsFieldName)(field);
+    return canonical !== null && applicantContactFieldNames.has(canonical) ? canonical : field;
+}
+/**
+ * The single decision for which payload field a fill step carries: the
+ * vocabulary/explicit field, else the instruction's own label — never when the
+ * author opted out (`payloadFieldNone`) or the vocabulary excludes the step.
+ * Shared so known-field and persona-binding registration cannot drift apart.
+ */
+function fieldForFillStep(step, vocabulary, knownFieldValues, canonicalise = false) {
+    const isObj = typeof step !== "string";
+    const instruction = isObj ? step.step : step;
+    const vocabField = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues, canonicalise);
+    if (vocabField !== null)
+        return vocabField;
+    if (isObj && step.payloadFieldNone)
+        return null;
+    if (vocabulary.exclusions.some((rx) => rx.test(instruction)))
+        return null;
+    const labelField = deriveFillLabelField(instruction);
+    return canonicalise && labelField !== null ? canonicalPayloadField(labelField) : labelField;
+}
 /**
  * Field→value pairs the flow establishes unambiguously via a Fill/Enter/Type
  * step — the applicant's own datum, per {@link deriveFillLabelField}'s same
@@ -307,14 +364,14 @@ function resolveStepPayloadField(instruction, explicit, forceNone, vocabulary =
  * (a field whose label mentions "phone" but whose select answer is a device
  * type, not a number).
  */
-function buildKnownFieldValues(flowSteps, vocabulary, env) {
+function buildKnownFieldValues(flowSteps, vocabulary, env, canonicalise = false) {
     const known = new Map();
     for (const step of flowSteps) {
         const isObj = typeof step !== "string";
         const instruction = isObj ? step.step : step;
         if (!/^\s*(?:fill(?:\s+in)?|enter|type)\b/i.test(instruction))
             continue;
-        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary) ?? deriveFillLabelField(instruction);
+        const field = fieldForFillStep(step, vocabulary, undefined, canonicalise);
         if (field === null)
             continue;
         const value = extractStepPersonaValue(instruction, env);
@@ -334,9 +391,9 @@ function buildKnownFieldValues(flowSteps, vocabulary, env) {
  * or the value-identity substitution silently misses.
  *
  * Two grammar facts, both verified against real ATS flows, drive the rule:
- *   1. The possessive apostrophe in "the candidate's first name 'Reginald'"
- *      opens a false quote — a naive `/'[^']*'/` yields `s first name `, not
- *      `Reginald`. Neutralizing `\w's` → `\ws` before matching removes it.
+ *   1. A letter-flanked apostrophe ("the candidate's first name 'Reginald'",
+ *      "Don't") is not a quote delimiter; the shared tokenizer skips it, so the
+ *      span is `Reginald`, not `s first name `.
  *   2. A `Select`/`Choose` step names the ANSWER first, then the question
  *      ("Select 'No' for the 'sponsorship' question"), so the value is the
  *      FIRST quoted token; a `Fill`/`Enter`/`Type` step names the field label
@@ -363,10 +420,10 @@ function extractStepPersonaValue(instruction, env) {
         if (resolved)
             return resolved;
     }
-    const spans = findQuoteSpans(instruction);
+    const spans = findInstructionSpans(instruction);
     if (spans.length === 0)
         return null;
-    const value = pickValueSpan(instruction, spans).value;
+    const value = pickValueSpan(instruction, spans).text;
     return value.length > 0 ? value : null;
 }
 /**
@@ -409,12 +466,26 @@ function extractNavigateToHashFragmentValue(url, previousHash) {
  * hash-bearing navigateTo; a hashless reset navigation must not erase it, or
  * the next cumulative hash would be taken whole and never recur in a request.
  */
-function walkNavigateToFacets(flowSteps) {
+function walkNavigateToFacets(flowSteps, env) {
     const facets = [];
     let baselineHash;
     for (const step of flowSteps) {
-        if (typeof step === "string" || step.navigateTo === undefined)
+        if (typeof step === "string")
+            continue;
+        if (step.navigateTo === undefined) {
+            if (step.payloadField && !step.payloadFieldNone) {
+                facets.push({
+                    value: extractStepPersonaValue(step.step, env),
+                    field: step.payloadField,
+                    optional: step.optional === true,
+                    origin: "step",
+                    literals: collectStepFacetLiterals(step.step, env),
+                    kind: deriveFacetKind(step.payloadField),
+                    kindHints: collectStepFacetKindHints(step.step, env),
+                });
+            }
             continue;
+        }
         const hashIndex = step.navigateTo.indexOf("#");
         const currentHash = hashIndex === -1 ? undefined : step.navigateTo.slice(hashIndex + 1);
         if (step.payloadField) {
@@ -422,6 +493,10 @@ function walkNavigateToFacets(flowSteps) {
                 value: extractNavigateToHashFragmentValue(step.navigateTo, baselineHash),
                 field: step.payloadField,
                 optional: step.optional === true,
+                origin: "navigateTo",
+                literals: collectHashFacetLiterals(step.navigateTo, baselineHash),
+                kind: deriveFacetKind(step.payloadField),
+                kindHints: collectHashFacetKindHints(step.navigateTo, baselineHash),
             });
         }
         if (currentHash !== undefined)
@@ -429,6 +504,99 @@ function walkNavigateToFacets(flowSteps) {
     }
     return facets;
 }
+/**
+ * Derives a facet's element kind from its declared field name (`tripLength`
+ * and `TripLength` both yield `trip length`), so a matcher can tell which
+ * captured element a literal belongs to without any site vocabulary.
+ */
+function deriveFacetKind(field) {
+    return field
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_\-\s]+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function uniqueLiterals(primary, others) {
+    return [...new Set([...(primary === null ? [] : [primary]), ...others])].filter((literal) => literal.length > 0);
+}
+function collectStepFacetLiterals(instruction, env) {
+    const primary = extractStepPersonaValue(instruction, env);
+    return uniqueLiterals(primary, findInstructionSpans(instruction).map((span) => span.text));
+}
+const STEP_KIND_STOP_WORDS = new Set([
+    "facet",
+    "filter",
+    "field",
+    "value",
+    "option",
+    "selection",
+    "the",
+    "a",
+    "an",
+    "dropdown",
+    "drop-down",
+    "selector",
+    "menu",
+    "list",
+    "widget",
+    "question",
+]);
+/**
+ * Element kinds a click step's own prose names: the noun phrase trailing the
+ * value span ("select the 'Lisbon' city option" names `city`), so a facet whose
+ * field name differs from the page's vocabulary can still own the element of
+ * that kind. Reads only the generic instruction grammar, no site vocabulary.
+ */
+function collectStepFacetKindHints(instruction, env) {
+    const value = extractStepPersonaValue(instruction, env);
+    const span = findInstructionSpans(instruction).find((candidate) => candidate.text === value);
+    if (span === undefined)
+        return [];
+    const phrase = instruction
+        .slice(span.end)
+        .split(/[.,;:]|\b(?:from|in|on|for|with|and|then|to)\b/i)[0];
+    const words = phrase
+        .split(/\s+/)
+        .map((word) => word.replace(/^['"]+|['"]+$/g, ""))
+        .filter((word) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(word));
+    const kindWords = words.filter((word) => !STEP_KIND_STOP_WORDS.has(word.toLowerCase()));
+    return [...new Set([...(kindWords.length > 1 ? [kindWords.join(" ")] : []), ...kindWords])];
+}
+function collectHashFacetLiterals(url, previousHash) {
+    const primary = extractNavigateToHashFragmentValue(url, previousHash);
+    const hashIndex = url.indexOf("#");
+    const rawTokens = hashIndex === -1 || previousHash === undefined
+        ? []
+        : splitHashTokens(url.slice(hashIndex + 1)).filter((token) => !splitHashTokens(previousHash).includes(token));
+    return uniqueLiterals(primary, rawTokens);
+}
+/**
+ * Further element kinds a facet's own hash names (`ship` in `#/ship/<slug>` or
+ * `ship=<slug>`, `ports` in `ports_<slug>`), for a field name that does not
+ * itself name the element kind. Kept beside the binding rather than on it so
+ * the binding's declared shape stays the contract callers build and compare.
+ */
+const FACET_KIND_HINTS = new WeakMap();
+/**
+ * Element kinds a hash facet's own tokens name: the key of a `key=value` pair,
+ * the path segment ahead of the value, and the `<kind>_` prefix of a slug.
+ */
+function collectHashFacetKindHints(url, previousHash) {
+    const hashIndex = url.indexOf("#");
+    if (hashIndex === -1)
+        return [];
+    const previousTokens = new Set(previousHash === undefined ? [] : splitHashTokens(previousHash));
+    const tokens = splitHashTokens(url.slice(hashIndex + 1));
+    const fresh = tokens.filter((token) => !previousTokens.has(token));
+    const valueToken = fresh[fresh.length - 1] ?? tokens[tokens.length - 1];
+    if (valueToken === undefined)
+        return [];
+    const value = stripHashKeyPrefix(valueToken);
+    const keyOfPair = valueToken.includes("=") ? valueToken.slice(0, valueToken.indexOf("=")) : "";
+    const ahead = tokens[tokens.indexOf(valueToken) - 1] ?? "";
+    const slugPrefix = value.includes("_") ? value.slice(0, value.indexOf("_")) : "";
+    return [keyOfPair, ahead, slugPrefix].filter((hint) => /^[A-Za-z][A-Za-z0-9 _-]*$/.test(hint));
+}
 function splitHashTokens(hash) {
     return hash.split(/[,/;&]/).filter((token) => token.length > 0);
 }
@@ -459,7 +627,7 @@ function stripHashKeyPrefix(token) {
 function deriveFillLabelField(instruction) {
     if (!/^\s*(?:fill(?:\s+in)?|enter|type)\b/i.test(instruction))
         return null;
-    if (!/'[^']*'/.test(instruction))
+    if (findInstructionSpans(instruction).length === 0)
         return null;
     const label = /\b(?:fill(?:\s+in)?|enter|type)\s+(?:in\s+)?the\s+(.+?)\s+field\b/i.exec(instruction)?.[1];
     if (label === undefined)
@@ -482,7 +650,7 @@ function deriveFillLabelField(instruction) {
 function harvestPersonaBindings(flowSteps, vocabulary, env) {
     const bindings = new Map();
     const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary, env);
-    for (const facet of walkNavigateToFacets(flowSteps)) {
+    for (const facet of walkNavigateToFacets(flowSteps, env)) {
         if (facet.value !== null && !bindings.has(facet.value)) {
             bindings.set(facet.value, `payload.${facet.field}`);
         }
@@ -499,16 +667,7 @@ function harvestPersonaBindings(flowSteps, vocabulary, env) {
         // fragment, not anything extractStepPersonaValue could find in `step.step`.
         if (isObj && step.navigateTo !== undefined)
             continue;
-        const vocabField = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues);
-        // Vocabulary wins outright. Only on a miss do we fall back to deriving the
-        // field from the instruction's own label — and never when the author opted
-        // the step out (`payloadFieldNone`) or the vocabulary explicitly excluded it.
-        const field = vocabField ??
-            (isObj && step.payloadFieldNone
-                ? null
-                : vocabulary.exclusions.some((rx) => rx.test(instruction))
-                    ? null
-                    : deriveFillLabelField(instruction));
+        const field = fieldForFillStep(step, vocabulary, knownFieldValues);
         if (field === null)
             continue;
         const value = extractStepPersonaValue(instruction, env);
@@ -534,12 +693,22 @@ function harvestPersonaBindings(flowSteps, vocabulary, env) {
  * aligned with the declared facets; {@link resolveRecurringNavigateToFacets}
  * drops the empty literal itself and keeps only a correlated value.
  */
-function extractNavigateToFacetOrder(flowSteps) {
-    return walkNavigateToFacets(flowSteps).map((facet) => ({
-        value: facet.value ?? "",
-        field: facet.field,
-        optional: facet.optional,
-    }));
+function extractNavigateToFacetOrder(flowSteps, env = process.env) {
+    return walkNavigateToFacets(flowSteps, env)
+        .filter((facet) => facet.origin === "navigateTo" || facet.value !== null)
+        .map((facet) => {
+        const binding = {
+            value: facet.value ?? "",
+            field: facet.field,
+            optional: facet.optional,
+            literals: facet.literals,
+            kind: facet.kind,
+            ...(facet.origin === "step" ? { origin: facet.origin } : {}),
+        };
+        if (facet.kindHints.length > 0)
+            FACET_KIND_HINTS.set(binding, facet.kindHints);
+        return binding;
+    });
 }
 /**
  * Detects a flow step whose quoted VALUE is the space-joined concatenation of
@@ -553,10 +722,10 @@ function extractNavigateToFacetOrder(flowSteps) {
  *   null when the step's value is not such a concatenation
  */
 function resolveCompositePersonaFields(instruction, knownFieldValues) {
-    const spans = findQuoteSpans(instruction);
+    const spans = findInstructionSpans(instruction);
     if (spans.length === 0)
         return null;
-    const value = pickValueSpan(instruction, spans).value;
+    const value = pickValueSpan(instruction, spans).text;
     if (value.length === 0)
         return null;
     for (const [fieldA, valueA] of knownFieldValues) {
@@ -1299,6 +1468,10 @@ function deriveBaseUrl(captures, ownBackendHostnames, submitPatterns = null) {
         return dominantHostOrigin(sameDomainCandidates);
     }
     const candidates = captures.filter((c) => (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, null));
+    if (candidates.length === 0) {
+        const captured = [...new Set(captures.map((c) => captureHostname(c.url)))].join(", ");
+        throw new Error(`ownBackendHostnames matched no capture: declared [${ownBackendHostnames.join(", ")}], captured hosts [${captured}]`);
+    }
     return dominantHostOrigin(candidates);
 }
 function firstCaptureOrigin(captures) {
@@ -1311,7 +1484,7 @@ function firstCaptureOrigin(captures) {
             // try next
         }
     }
-    return "https://example.com";
+    throw new Error(`no capture has a parseable URL to derive a base URL from (${captures.length} candidate captures)`);
 }
 /**
  * Extracts caller-supplied job/context coordinates from the recon ENTRY URL's
@@ -3804,11 +3977,8 @@ function buildSelectOptionResolutions(flowSteps, captures, vocabulary, env) {
         // returns first-quote when the sentence STARTS with select/choose/pick; a
         // dropdown step phrased "On the X step, select 'No' in the '…?' dropdown"
         // starts with "On", so read the first quote directly here for id= steps.
-        const firstQuoteLabel = (() => {
-            const cleaned = instruction.replace(/(\w)'s\b/g, "$1s");
-            const m = /'([^']*)'/.exec(cleaned);
-            return m && m[1].length > 0 ? m[1] : null;
-        })();
+        const firstQuoteText = findInstructionSpans(instruction)[0]?.text;
+        const firstQuoteLabel = firstQuoteText ? firstQuoteText : null;
         const label = idMatch ? firstQuoteLabel : extractStepPersonaValue(instruction, env);
         if (label === null)
             continue;
@@ -5998,9 +6168,14 @@ function applyScalarFacetSplicePayloadSubstitutions(template, inputBody, navigat
             continue;
         const literal = JSON.stringify(value);
         const fallback = facet.optional ? ` ?? ${literal}` : "";
-        const replacement = typeof value === "number" || facet.optional
-            ? `\${JSON.stringify(payload.${facet.field}${fallback})}`
-            : `"\${payload.${facet.field}}"`;
+        const casing = facetCaseMethod(String(value), facet);
+        const expression = facetPayloadExpression(facet, fallback);
+        const cased = casing ? `String(${expression}).${casing}()` : undefined;
+        const replacement = cased
+            ? `\${JSON.stringify(${cased})}`
+            : typeof value === "number" || facet.optional
+                ? `\${JSON.stringify(${expression})}`
+                : `"\${${expression}}"`;
         for (const sep of [":", ": "]) {
             if (typeof value === "number") {
                 const re = new RegExp(`${sep}${literal}(?![\\w.])`, "g");
@@ -6062,11 +6237,36 @@ function applyArrayFacetSplicePayloadSubstitutions(template, inputBody, navigate
         }
         const absentFacets = collectSiblingArrayFacets(value, path, siblingBodies, navigateToFacets);
         const absentFields = new Set(absentFacets.map(({ facet }) => facet.field));
-        const expression = renderFacetValueExpression([...value, ...absentFacets.map(({ element }) => element)], navigateToFacets.map((facet) => absentFields.has(facet.field) ? { ...facet, optional: true } : facet));
+        const expression = renderFacetValueExpression(insertAbsentFacetElements(value, absentFacets), navigateToFacets.map((facet) => absentFields.has(facet.field) ? { ...facet, optional: true } : facet));
         result = replaceJsonArrayOccurrences(result, value, `\${JSON.stringify(${expression})}`);
     }
     return result;
 }
+/**
+ * Inserts each sibling-only element next to its nearest neighbour that `own`
+ * (or an earlier insertion) also carries, so the emitted order follows the
+ * capture it came from. With no shared neighbour it is appended.
+ */
+function insertAbsentFacetElements(own, absent) {
+    const merged = [...own];
+    const indexOfElement = (target) => merged.findIndex((candidate) => JSON.stringify(candidate) === JSON.stringify(target));
+    for (const { element, before, after } of absent) {
+        const previous = [...before]
+            .reverse()
+            .map(indexOfElement)
+            .find((index) => index >= 0);
+        if (previous !== undefined) {
+            merged.splice(previous + 1, 0, element);
+            continue;
+        }
+        const next = after.map(indexOfElement).find((index) => index >= 0);
+        if (next === undefined)
+            merged.push(element);
+        else
+            merged.splice(next, 0, element);
+    }
+    return merged;
+}
 /**
  * Facet-bearing elements that same-endpoint sibling captures carry at the
  * array `path` but `own` does not. A fold drill re-issues ONE representative
@@ -6084,14 +6284,19 @@ function collectSiblingArrayFacets(own, path, siblingBodies, facets) {
         for (const { value, path: siblingPath } of walkArrayLeaves(body)) {
             if (arrayPathKey(siblingPath) !== key)
                 continue;
-            for (const element of value) {
+            for (const [index, element] of value.entries()) {
                 if (typeof element !== "string")
                     continue;
                 const facet = matchArrayElementFacet(element, facets);
                 if (facet === undefined || present.has(facet.field))
                     continue;
                 present.add(facet.field);
-                absent.push({ element, facet });
+                absent.push({
+                    element,
+                    facet,
+                    before: value.slice(0, index),
+                    after: value.slice(index + 1),
+                });
             }
         }
     }
@@ -6495,6 +6700,16 @@ function parseUrlQueryParams(url) {
     }
     return params;
 }
+/** Every query value of a URL, repeated keys included (`?f=a&f=b`), where
+ * {@link parseUrlQueryParams} keeps only the last per key. */
+function parseUrlQueryValues(url) {
+    try {
+        return [...new URL(url).searchParams.values()];
+    }
+    catch {
+        return [];
+    }
+}
 /** Parses a captured JSON request body into its string leaf values. Returns
  * an empty array when the body is absent or not valid JSON. */
 function parseBodyLeafValues(requestPostData) {
@@ -6587,9 +6802,11 @@ function bindsWithoutCollisionIn(bodies, value) {
  * so facet reachability agrees with the token-boundary {@link matchFacetRecurrence}
  * the splice passes use instead of counting a mere substring of a longer token.
  */
-function occursAtTokenBoundary(text, value) {
-    if (value.length === 0)
+function occursAtTokenBoundary(rawText, rawValue, ignoreCase = false) {
+    if (rawValue.length === 0)
         return false;
+    const text = ignoreCase ? rawText.toLowerCase() : rawText;
+    const value = ignoreCase ? rawValue.toLowerCase() : rawValue;
     const isAlnum = (ch) => ch !== undefined && /[A-Za-z0-9]/.test(ch);
     let from = 0;
     while (true) {
@@ -6610,22 +6827,61 @@ function occursAtTokenBoundary(text, value) {
  * deciding from the hash-derived literal alone.
  */
 function resolveRecurringNavigateToFacets(declared, actions) {
-    const appearsAnywhere = (value) => actions.some(({ capture }) => occursAtTokenBoundary(capture.url, value) ||
+    const appearsAnywhere = (value) => actions.some(({ capture }) => occursAtTokenBoundary(capture.url, value, true) ||
         (capture.requestPostData != null &&
-            occursAtTokenBoundary(capture.requestPostData, value)) ||
-        Object.values(capture.requestHeaders).some((h) => occursAtTokenBoundary(h, value)));
+            occursAtTokenBoundary(capture.requestPostData, value, true)) ||
+        Object.values(capture.requestHeaders).some((h) => occursAtTokenBoundary(h, value, true)));
     const reachable = declared.filter(({ value }) => value.length > 0 && appearsAnywhere(value));
-    const resolvedDeclared = declared.filter(({ value }) => value.length > 0);
-    const unreachable = declared.filter((facet) => !reachable.includes(facet));
-    if (unreachable.length === 0)
+    const resolvedDeclared = declared.filter((facet) => facet.value.length > 0 && (facet.origin !== "step" || reachable.includes(facet)));
+    const unreachable = declared.filter((facet) => facet.origin !== "step" && !reachable.includes(facet));
+    // Every declared facet also owns the elements of its own kind in the code
+    // vocabulary, whether or not its declared literal recurs: a literal that
+    // recurs in one vocabulary (a hash slug, a quoted label) says nothing about
+    // the same facet's element in another (`WW;filterType=ship`).
+    const claimedLiterals = new Set();
+    const pairsByField = new Map();
+    const aliased = declared
+        .flatMap((facet) => findKindKeyedLiterals(facet, actions).flatMap((literal) => {
+        if (declared.some(({ value }) => value === literal))
+            return [];
+        if (claimedLiterals.has(literal))
+            return [];
+        claimedLiterals.add(literal);
+        const known = [facet.value, ...(facet.literals ?? [])];
+        // A case-only variant is already owned by the declared facet, whose
+        // renderer re-cases any caller value to the captured element's casing.
+        if (known.some((candidate) => candidate.toLowerCase() === literal.toLowerCase()))
+            return [];
+        // The traffic carries codes, not which declared value each belongs to;
+        // pair only where the code abbreviates the value, never by position.
+        const sameField = declared.filter(({ field, value }) => field === facet.field && value.length > 0);
+        const abbreviated = sameField.filter(({ value }) => abbreviates(literal, value));
+        const owners = abbreviated.length > 0 || sameField.length !== 1 ? abbreviated : sameField;
+        if (owners.length > 0)
+            pairsByField.set(facet.field, [
+                ...(pairsByField.get(facet.field) ?? []),
+                ...owners.map((owner) => [owner.value, literal]),
+            ]);
+        return [{ ...facet, value: literal, literals: [literal], keyedByKind: true }];
+    }))
+        .map((alias) => {
+        const pairs = pairsByField.get(alias.field) ?? [];
+        return pairs.length === 0 ? alias : { ...alias, valueMap: new Map(pairs) };
+    });
+    if (unreachable.length === 0 && aliased.length === 0)
         return resolvedDeclared;
-    const correlated = correlateUnreachableNavigateToFacets(unreachable, actions, reachable.map(({ value }) => value));
+    const aliasedFields = new Set(aliased.map(({ field }) => field));
+    const awaiting = unreachable.filter(({ field }) => !aliasedFields.has(field));
+    const withAliases = [...resolvedDeclared, ...aliased];
+    if (awaiting.length === 0)
+        return withAliases;
+    const correlated = correlateUnreachableNavigateToFacets(awaiting, actions, [...reachable, ...aliased].map(({ value }) => value));
     if (correlated === null)
-        return resolvedDeclared;
+        return withAliases;
     const bodies = actions
         .map(({ capture }) => capture.requestPostData)
         .filter((body) => typeof body === "string" && body.length > 0);
-    const extras = unreachable.flatMap((facet) => {
+    const extras = awaiting.flatMap((facet) => {
         const diffed = correlated.get(facet.field);
         if (diffed === undefined || diffed.length === 0)
             return [];
@@ -6633,7 +6889,52 @@ function resolveRecurringNavigateToFacets(declared, actions) {
             return [];
         return bindsWithoutCollisionIn(bodies, diffed) ? [{ ...facet, value: diffed }] : [];
     });
-    return [...resolvedDeclared, ...extras];
+    return [...withAliases, ...extras];
+}
+/**
+ * The literals a facet takes in the code vocabulary: the captured request
+ * element (query value or body string leaf) whose `<literal><delim>key=<kind>`
+ * suffix names the facet's own kind. Derived from the traffic itself, so it
+ * never depends on how many other facets or transitions the flow declared.
+ * A kind carrying several distinct literals across captures yields each of
+ * them, so every element of the kind is owned instead of none; the month
+ * evidence narrows them only when it singles out some of them.
+ */
+function findKindKeyedLiterals(facet, actions) {
+    const byTier = new Map();
+    const sameMonth = new Set();
+    const facetMonths = new Set([facet.value, ...(facet.literals ?? [])]
+        .map((literal) => monthCodeOf(literal))
+        .filter((code) => code !== undefined));
+    const yearlessMonths = new Set([facet.value, ...(facet.literals ?? [])]
+        .map((literal) => bareMonthNumberOf(literal))
+        .filter((month) => month !== undefined));
+    for (const { capture } of actions) {
+        const values = [
+            ...parseUrlQueryValues(capture.url),
+            ...parseBodyLeafValues(capture.requestPostData),
+        ];
+        for (const value of values) {
+            const parsed = parseElementKind(value);
+            if (parsed === undefined)
+                continue;
+            const tier = kindMatchTier(facet, parsed.kind);
+            if (tier > 0)
+                byTier.set(tier, (byTier.get(tier) ?? new Set()).add(parsed.literal));
+            const month = monthCodeOf(parsed.literal);
+            const isOwnLiteral = [facet.value, ...(facet.literals ?? [])].some((known) => known.toLowerCase() === parsed.literal.toLowerCase());
+            if (month !== undefined &&
+                !isOwnLiteral &&
+                (facetMonths.has(month) || yearlessMonths.has(month.slice("YYYY-".length)))) {
+                sameMonth.add(parsed.literal);
+            }
+        }
+    }
+    const closest = [...byTier.entries()].sort(([a], [b]) => a - b)[0]?.[1];
+    if (closest === undefined)
+        return sameMonth.size === 1 ? [...sameMonth] : [];
+    const sameMonthInKind = [...closest].filter((literal) => sameMonth.has(literal));
+    return sameMonthInKind.length > 0 && closest.size > 1 ? sameMonthInKind : [...closest];
 }
 /**
  * Resolves each zero-recurrence navigateTo facet (in flow order) to the real
@@ -6718,7 +7019,7 @@ flowSteps = [], vocabulary = undefined) {
     // below can correlate a REST body's facet-packed string leaves against it.
     const { payloadFieldNames: restPayloadFieldNames, optionalPayloadFieldNames: restOptionalFieldNames, } = computeFlowPayloadFieldNames(flowSteps, vocabulary, process.env);
     const payloadAccessorByValue = new Map();
-    const declaredNavigateToFacets = extractNavigateToFacetOrder(flowSteps);
+    const declaredNavigateToFacets = extractNavigateToFacetOrder(flowSteps, process.env);
     const navigateToFacetOrder = resolveRecurringNavigateToFacets(declaredNavigateToFacets, actions);
     const facetArrayPathKeys = collectFacetArrayPathKeys(actions.map((action) => parseJsonBodyOrNull(action.capture.requestPostData)), navigateToFacetOrder);
     if (inputBody !== undefined && inputBody !== null) {
@@ -8081,17 +8382,171 @@ function matchArrayElementFacet(element, facets) {
  */
 function matchFacetRecurrence(text, facets, options) {
     const isAlnum = (ch) => ch !== undefined && /[A-Za-z0-9]/.test(ch);
-    return facets.reduce((best, facet) => {
-        const literal = facet.value;
-        const matches = text === literal ||
-            (options.allowDelimiterSuffix &&
-                literal.length > 0 &&
-                text.startsWith(literal) &&
-                !isAlnum(text[literal.length]));
-        if (!matches)
+    const parsedElement = parseElementKind(text);
+    const elementKind = parsedElement?.kind;
+    // A kind no declared facet names (an identifier format such as
+    // `<slug>;filterId=urlFriendlyId`) cannot belong to another facet, so the
+    // kind gate only protects elements some facet claims; a whole-literal
+    // match there still binds the facet whose literal the element carries.
+    const kindUnclaimed = elementKind !== undefined && !facets.some((candidate) => kindsMatch(candidate, elementKind));
+    const pick = (ignoreCase) => facets.reduce((best, facet) => {
+        const readFromElement = facet.keyedByKind === true && parsedElement?.literal === facet.value;
+        const ownsUnclaimedKind = kindUnclaimed &&
+            [facet.value, ...(facet.literals ?? [])].some((known) => known.toLowerCase() === parsedElement?.literal.toLowerCase());
+        if (elementKind !== undefined &&
+            isKindKeyed(facet) &&
+            !readFromElement &&
+            !ownsUnclaimedKind &&
+            !kindsMatch(facet, elementKind)) {
+            return best;
+        }
+        const literal = [facet.value, ...(facet.literals ?? [])]
+            .filter((candidate) => {
+            const same = (value) => ignoreCase ? value.toLowerCase() === candidate.toLowerCase() : value === candidate;
+            return (candidate.length > 0 &&
+                (same(text) ||
+                    (options.allowDelimiterSuffix &&
+                        same(text.slice(0, candidate.length)) &&
+                        !isAlnum(text[candidate.length]))));
+        })
+            .reduce((longest, candidate) => longest === undefined || candidate.length > longest.length ? candidate : longest, undefined);
+        const matchedLiteral = literal;
+        if (matchedLiteral === undefined)
             return best;
-        return best === undefined || literal.length > best.value.length ? facet : best;
+        const matched = matchedLiteral === facet.value ? facet : { ...facet, value: matchedLiteral };
+        return best === undefined || matchedLiteral.length > best.value.length ? matched : best;
     }, undefined);
+    return pick(false) ?? pick(true);
+}
+/**
+ * Splits an element of the grammar `<literal><delim><key>=<kind>` into its
+ * literal and kind, or returns `undefined` when the element carries no kind
+ * suffix. Structural only — no key or kind vocabulary is assumed.
+ */
+function parseElementKind(element) {
+    const parsed = /^(.+)[;&|,]([^;&|,=]+)=([^;&|,=]+)$/.exec(element);
+    return parsed ? { literal: parsed[1], kind: parsed[3] } : undefined;
+}
+function normalizeKind(kind) {
+    return deriveFacetKind(kind).replace(/\s+/g, "").replace(/s$/, "");
+}
+const KIND_NOISE_WORDS = new Set(["facet", "filter", "field", "value", "option", "selection"]);
+/**
+ * How closely a facet names an element's kind, 0 when it does not: 1 for the
+ * declared field (qualifier words such as `facet` dropped) or a hash-named
+ * hint equal to the kind, 2 when the field's trailing word is the kind
+ * (`sailDate` names a `date` element), 3 when any other word of the field is.
+ * A caller picking an element for the facet takes the closest tier, so a field
+ * naming two kinds still resolves to the one it ends with.
+ */
+function kindMatchTier(facet, elementKind) {
+    const element = normalizeKind(elementKind);
+    if (element.length === 0 || facet.kind === undefined)
+        return 0;
+    const words = deriveFacetKind(facet.kind).split(" ");
+    const meaningful = words.filter((word) => !KIND_NOISE_WORDS.has(word));
+    const named = meaningful.length > 0 ? meaningful : words;
+    if (normalizeKind(facet.kind) === element || normalizeKind(named.join(" ")) === element)
+        return 1;
+    if ((FACET_KIND_HINTS.get(facet) ?? []).some((hint) => normalizeKind(hint) === element))
+        return 1;
+    if (normalizeKind(named[named.length - 1] ?? "") === element)
+        return 2;
+    return named.some((word) => normalizeKind(word) === element) ? 3 : 0;
+}
+function kindsMatch(facet, elementKind) {
+    return kindMatchTier(facet, elementKind) > 0;
+}
+const MONTH_NAMES = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+];
+/**
+ * Normalizes a month written as a slug or label (`december-2026`, `Dec 2026`,
+ * `2026-12`) to `YYYY-MM`, so the same month matches across vocabularies.
+ */
+function monthCodeOf(literal) {
+    const text = literal.trim();
+    const iso = /^(\d{4})[-/](0[1-9]|1[0-2])$/.exec(text);
+    if (iso)
+        return `${iso[1]}-${iso[2]}`;
+    const named = /^([A-Za-z]{3,9})[\s_/-]+(\d{4})$/.exec(text) ?? /^(\d{4})[\s_/-]+([A-Za-z]{3,9})$/.exec(text);
+    if (!named)
+        return undefined;
+    const yearFirst = /^\d{4}$/.test(named[1]);
+    const name = (yearFirst ? named[2] : named[1]).toLowerCase();
+    const year = yearFirst ? named[1] : named[2];
+    const index = MONTH_NAMES.findIndex((month) => month === name || (name.length === 3 && month.startsWith(name)));
+    return index === -1 ? undefined : `${year}-${String(index + 1).padStart(2, "0")}`;
+}
+/** Month number (`12`) of a month written without a year (`december`, `Dec`),
+ * so a facet whose literal names only the month still matches a dated element. */
+function bareMonthNumberOf(literal) {
+    const name = literal.trim().toLowerCase();
+    const index = MONTH_NAMES.findIndex((month) => month === name || (name.length === 3 && month.startsWith(name)));
+    return index === -1 ? undefined : String(index + 1).padStart(2, "0");
+}
+function isKindKeyed(facet) {
+    return (facet.kind !== undefined &&
+        facet.kind.length > 0 &&
+        (facet.origin === "step" || facet.keyedByKind === true));
+}
+/**
+ * Renders the payload value for a matched facet in the casing the captured
+ * element carried, so a caller sending the declared literal reproduces the
+ * captured request exactly. An exact-case or mixed-case occurrence is emitted
+ * untouched.
+ */
+function facetCaseMethod(captured, facet) {
+    const prefix = captured.slice(0, facet.value.length);
+    if (prefix === facet.value)
+        return undefined;
+    if (prefix === facet.value.toUpperCase())
+        return "toUpperCase";
+    if (prefix === facet.value.toLowerCase())
+        return "toLowerCase";
+    return undefined;
+}
+/** True when `code`'s letters occur in order within `value`, starting at its first letter (`LIS` in `Lisbon`). */
+function abbreviates(code, value) {
+    const letters = code.toLowerCase().replace(/[^a-z]/g, "");
+    const target = value.toLowerCase();
+    if (letters.length === 0 || letters[0] !== target[0])
+        return false;
+    let from = 0;
+    for (const letter of letters) {
+        from = target.indexOf(letter, from) + 1;
+        if (from === 0)
+            return false;
+    }
+    return true;
+}
+/**
+ * JS expression for the value a facet's payload field carries in the code
+ * vocabulary: a kind-keyed alias translates the caller's declared literal
+ * through its `valueMap`, passing an already-coded value through untouched.
+ */
+function facetPayloadExpression(facet, fallback = "") {
+    const raw = `payload.${facet.field}${fallback}`;
+    if (!facet.valueMap || facet.valueMap.size === 0)
+        return raw;
+    const entries = JSON.stringify([...facet.valueMap.entries()]);
+    return `(new Map(${entries}).get(String(payload.${facet.field})) ?? ${raw})`;
+}
+function renderFacetPayloadValue(captured, facet) {
+    const method = facetCaseMethod(captured, facet);
+    const expression = facetPayloadExpression(facet);
+    return method ? `\${String(${expression}).${method}()}` : `\${${expression}}`;
 }
 /**
  * Binds a top-level GraphQL variable whose scalar value (or, for a string, any
@@ -8104,8 +8559,12 @@ function spliceFacetRecurrenceIntoScalarVariable(value, facets) {
         return null;
     if (typeof value === "string" || typeof value === "number") {
         const facet = matchFacetRecurrence(String(value), facets, { allowDelimiterSuffix: false });
-        if (facet !== undefined)
-            return `payload.${facet.field}`;
+        if (facet !== undefined) {
+            const rendered = renderFacetPayloadValue(String(value), facet);
+            return rendered === `\${${facetPayloadExpression(facet)}}`
+                ? facetPayloadExpression(facet)
+                : `\`${rendered}\``;
+        }
     }
     if (typeof value !== "string")
         return null;
@@ -8127,7 +8586,7 @@ function spliceFacetRecurrenceIntoScalarVariable(value, facets) {
             continue;
         }
         bound = true;
-        const unit = `\`${escapeForTemplateLiteral(segment.slice(0, colonIndex + 1))}\${payload.${facet.field}}${escapeForTemplateLiteral(trailingDelimiter)}\``;
+        const unit = `\`${escapeForTemplateLiteral(segment.slice(0, colonIndex + 1))}${renderFacetPayloadValue(segment.slice(colonIndex + 1), facet)}${escapeForTemplateLiteral(trailingDelimiter)}\``;
         // An absent optional facet drops its own segment (and delimiter) rather
         // than rendering the string `undefined` into the packed value.
         if (facet.optional) {
@@ -8170,7 +8629,7 @@ function spliceFacetsIntoArrayVariable(value, facets, renderElement = (element)
             return renderElement(element);
         matchCount++;
         const suffix = element.slice(matched.value.length);
-        const elementLiteral = `\`\${payload.${matched.field}}${escapeForTemplateLiteral(suffix)}\``;
+        const elementLiteral = `\`${renderFacetPayloadValue(element, matched)}${escapeForTemplateLiteral(suffix)}\``;
         return matched.optional
             ? `...(payload.${matched.field} ? [${elementLiteral}] : [])`
             : elementLiteral;
@@ -8602,29 +9061,36 @@ function collectRequestStringValues(capture, allCaptures) {
  */
 function isExplainedByCorrelatedSiblingField(path, parsedBody, otherBodies, siblingPaths) {
     const allBodies = [parsedBody, ...otherBodies];
-    for (const siblingPath of siblingPaths) {
-        const pathSegments = siblingPath.split(".");
+    const siblingReaders = [
+        ...[...siblingPaths].map((siblingPath) => {
+            const pathSegments = siblingPath.split(".");
+            return (body) => {
+                const siblingRaw = readComparableBodyLeaf(parsedBody, body, pathSegments);
+                return siblingRaw === undefined ? undefined : String(siblingRaw);
+            };
+        }),
+        ...selfDescribingArrayPaths(parsedBody).map((arrayPath) => (body) => {
+            const array = readValueAtPath(body, arrayPath);
+            return Array.isArray(array) ? identityShape(array) : ABSENT_ARRAY_SHAPE;
+        }),
+    ];
+    return siblingReaders.some((readSibling) => {
         const pairs = [];
-        let sawUnexplainableField = false;
         for (const body of allBodies) {
             const fieldRaw = readComparableBodyLeaf(parsedBody, body, path);
             if (fieldRaw === undefined)
                 continue;
-            const siblingRaw = readComparableBodyLeaf(parsedBody, body, pathSegments);
-            if (siblingRaw === undefined) {
-                // This body has a value for the field we're trying to explain but no
-                // value for the candidate sibling — the sibling can't vouch for it,
-                // so don't let a function fitted over the OTHER bodies paper over it.
-                sawUnexplainableField = true;
-                break;
-            }
-            pairs.push({ siblingValue: String(siblingRaw), fieldValue: String(fieldRaw) });
+            const siblingValue = readSibling(body);
+            // This body has a value for the field we're trying to explain but no
+            // value for the candidate sibling — the sibling can't vouch for it, so
+            // don't let a function fitted over the OTHER bodies paper over it.
+            if (siblingValue === undefined)
+                return false;
+            pairs.push({ siblingValue, fieldValue: String(fieldRaw) });
         }
-        if (sawUnexplainableField)
-            continue;
         const distinctSiblingValues = new Set(pairs.map((p) => p.siblingValue));
         if (distinctSiblingValues.size < 2)
-            continue;
+            return false;
         const siblingToField = new Map();
         const isFunction = pairs.every(({ siblingValue, fieldValue }) => {
             const existing = siblingToField.get(siblingValue);
@@ -8634,10 +9100,8 @@ function isExplainedByCorrelatedSiblingField(path, parsedBody, otherBodies, sibl
             }
             return existing === fieldValue;
         });
-        if (isFunction && siblingToField.size === distinctSiblingValues.size)
-            return true;
-    }
-    return false;
+        return isFunction && siblingToField.size === distinctSiblingValues.size;
+    });
 }
 /**
  * Finds every query param or JSON body leaf on `capture`'s own request that
@@ -9709,6 +10173,32 @@ function arrayElementIdentity(element) {
         return undefined;
     return ARRAY_ELEMENT_IDENTITY.exec(element)?.[1];
 }
+/** The `<delimiter><name>` head of an {@link arrayElementIdentity} (its tag
+ * dropped), the part that says what ROLE an element plays in its array. */
+function identityName(identity) {
+    return identity?.slice(0, identity.indexOf("="));
+}
+/** Order-insensitive fingerprint of the identity suffixes an array carries —
+ * two arrays with equal fingerprints are the same shape (reordered, or with
+ * only values changed), anything else is a different shape or length. */
+function identityShape(elements) {
+    return elements
+        .map((element) => arrayElementIdentity(element) ?? "")
+        .sort()
+        .join("\u0000");
+}
+const ABSENT_ARRAY_SHAPE = "\u0001absent";
+/** Paths of every array in `body` that lists self-describing string elements
+ * (see {@link arrayElementIdentity}). Which identity suffixes such an array
+ * carries is itself a property of the request — a sibling field that differs
+ * only because the array took a different shape is explained by that shape. */
+function selfDescribingArrayPaths(body, path = []) {
+    if (body === null || typeof body !== "object")
+        return [];
+    const children = Object.entries(body).flatMap(([key, child]) => selfDescribingArrayPaths(child, [...path, key]));
+    const isSelfDescribing = Array.isArray(body) && body.some((element) => arrayElementIdentity(element) !== undefined);
+    return isSelfDescribing ? [[...path], ...children] : children;
+}
 /**
  * Index of the innermost path segment that indexes into an array (the array
  * holding the leaf, or one holding an object element that carries it), or -1.
@@ -9728,7 +10218,13 @@ function innermostArrayIndexSegment(body, path) {
  * field of an object element) is matched by its identity suffix within the same
  * array, never by index, so differently shaped arrays are not mistaken for one
  * array with a varying slot; an identity the other body lacks yields
- * `undefined`. A plain element of such an array is matched by value, since its
+ * `undefined`. An identity shared by several elements of either array (e.g.
+ * repeated `;tag=x` suffixes) is ambiguous and is paired only by exact value.
+ * When the arrays differ in shape or length, an identity is trusted only if
+ * its `;name=` role is also unique in both: a tag repeated by position
+ * (`;tagId=t0`, `;tagId=t1`) in two unrelated arrays says nothing about the
+ * elements being the same one.
+ * A plain element of such an array is matched by value, since its
  * slot says nothing about it once the arrays' shapes differ. Every other path
  * defers to {@link readValueAtPath}.
  */
@@ -9755,7 +10251,19 @@ function readComparableBodyLeaf(body, otherBody, path) {
         return leaf;
     if (identity === undefined)
         return undefined;
-    return counterparts.find((candidate) => arrayElementIdentity(candidate) === identity);
+    const ownCounterparts = ownArray.map((element) => readValueAtPath(element, elementSubpath));
+    const sharesIdentity = (candidate) => arrayElementIdentity(candidate) === identity;
+    const ownSharing = ownCounterparts.filter(sharesIdentity);
+    const otherSharing = counterparts.filter(sharesIdentity);
+    if (ownSharing.length !== 1 || otherSharing.length !== 1)
+        return undefined;
+    const name = identityName(identity);
+    const nameIsUnique = (values) => values.filter((value) => identityName(arrayElementIdentity(value)) === name).length === 1;
+    const isSameShape = identityShape(ownCounterparts) === identityShape(counterparts);
+    if (!isSameShape && !(nameIsUnique(ownCounterparts) && nameIsUnique(counterparts))) {
+        return undefined;
+    }
+    return otherSharing[0];
 }
 /**
  * Turns a flow author's plain dot-separated {@link FoldReturnSpec.resultsPath}
@@ -11339,10 +11847,48 @@ function declaredSchemaCoversAccessorShape(declared, shape) {
     const childShapes = [...(shape.element ? [shape.element] : []), ...shape.keys.values()];
     return ([...shape.keys.keys()].every((key) => new RegExp(`(?:^|[\\s{,])"?${key.replace(/[$]/g, "\\$&")}"?\\s*:`).test(declared)) && childShapes.every((child) => declaredSchemaCoversAccessorShape(declared, child)));
 }
+const applicantContactFieldNames = new Set([
+    "FirstName",
+    "LastName",
+    "Phone",
+    "AddressLine",
+    "City",
+    "State",
+    "PostalCode",
+    "Country",
+    "County",
+    "Resume",
+    "ResumeContentType",
+    "ResumeFilename",
+    "ResumeBase64",
+]);
+const baseContractFieldNames = new Set(["Email", "ClickUrl", "Answers"]);
+const applicantContactEvidenceFieldNamesLower = new Set([...applicantContactFieldNames, ...baseContractFieldNames].map((name) => name.toLowerCase()));
+/**
+ * Single source of truth for "the contract extends ApplicantContactSchema", so
+ * the contract and browser-flow emitters can't disagree about whether the
+ * payload carries Resume fields.
+ */
+function contractUsesApplicantContactSchema(opts) {
+    const { inputBody, isSubmissionFlow, browserFlowOnly, payloadFieldNames } = opts;
+    // A browser-flow-only submission flow has no HTTP body of its own: whatever
+    // inputBody HTTP analysis captured describes a path the plugin won't emit,
+    // so it is not evidence about the real caller's shape.
+    if (isSubmissionFlow === true && browserFlowOnly === true)
+        return true;
+    // A body-less submission flow has no inputBody to inspect; the payload fields
+    // its steps splice are the only evidence, whether or not it also has an HTTP
+    // path (the browser-flow emitter can't know which the contract will take).
+    if (inputBody != null) {
+        return [...walkAllPrimitiveLeaves(inputBody)].some(({ path }) => path.some((segment) => applicantContactEvidenceFieldNamesLower.has(segment.toLowerCase())));
+    }
+    return (isSubmissionFlow === true &&
+        [...(payloadFieldNames ?? [])].some((name) => applicantContactEvidenceFieldNamesLower.has(name.toLowerCase())));
+}
 /** Generates a complete contract.ts source string for a plugin — exported so
  * unit tests can drive the emitter directly without spawning the CLI. */
 function emitContractTs(opts) {
-    const { siteId, displayName, pascal, baseUrl, baseHeaders, minTime, safeRps, hasRateLimitProbeData = false, responseBody, responseBodySamples = [responseBody], gql, gqlQuery, endpointPath, gqlOperationName, gqlVariables, allCaptures = [], auxFiles, multiStepBody, omitExecuteHttp = false, isSubmissionFlow = false, inputBody, hasMultipartStep = false, actionSteps = [], foldReturnSpec = null, discoveredFormFields, fieldOptionsMap, discoveredOptionFields, discoveredRawOptionFields, discoveredAdditionalBodyKeys, discoveredStructuredKeys, valueConstraints = value_constraints_1.EMPTY_VALUE_CONSTRAINTS, payloadFieldNames, optionalPayloadFieldNames = new Set(), flowSteps: contractFlowSteps = [], headerBindings = [], unpopulatedDeclaredVariables = [], fallbackGateSpec = {}, } = opts;
+    const { siteId, displayName, pascal, baseUrl, baseHeaders, minTime, safeRps, hasRateLimitProbeData = false, responseBody, responseBodySamples = [responseBody], gql, gqlQuery, endpointPath, gqlOperationName, gqlVariables, allCaptures = [], auxFiles, multiStepBody, omitExecuteHttp = false, createsAccount = false, isSubmissionFlow = false, inputBody, hasMultipartStep = false, actionSteps = [], foldReturnSpec = null, discoveredFormFields, fieldOptionsMap, discoveredOptionFields, discoveredRawOptionFields, discoveredAdditionalBodyKeys, discoveredStructuredKeys, valueConstraints = value_constraints_1.EMPTY_VALUE_CONSTRAINTS, payloadFieldNames, optionalPayloadFieldNames = new Set(), flowSteps: contractFlowSteps = [], headerBindings = [], unpopulatedDeclaredVariables = [], fallbackGateSpec = {}, } = opts;
     const { browserFallbackGate, httpTimeoutMs } = fallbackGateSpec;
     /** Single source of truth for every GraphQL-emission decision below
      * (clientImport, gqlCacheBlock, queryConst, and both executeHttpBody
@@ -11419,26 +11965,13 @@ function emitContractTs(opts) {
     // one of ApplicantContactSchema's own field names (case-insensitively,
     // checked at any depth via walkAllPrimitiveLeaves) before the template
     // applies (see recon-generate-payload-schema-mismatch.md).
-    const applicantContactFieldNames = new Set([
-        "FirstName",
-        "LastName",
-        "Phone",
-        "AddressLine",
-        "City",
-        "State",
-        "PostalCode",
-        "Country",
-        "County",
-        "Resume",
-        "ResumeContentType",
-        "ResumeFilename",
-        "ResumeBase64",
-    ]);
-    const baseContractFieldNames = new Set(["Email", "ClickUrl", "Answers"]);
-    const applicantContactEvidenceFieldNamesLower = new Set([...applicantContactFieldNames, ...baseContractFieldNames].map((name) => name.toLowerCase()));
-    const usesApplicantContactSchema = inputBody != null &&
-        [...walkAllPrimitiveLeaves(inputBody)].some(({ path }) => path.some((segment) => applicantContactEvidenceFieldNamesLower.has(segment.toLowerCase())));
-    const isReservedByApplicantContactSchema = (name) => usesApplicantContactSchema && applicantContactFieldNames.has(name);
+    const usesApplicantContactSchema = contractUsesApplicantContactSchema({
+        inputBody,
+        isSubmissionFlow,
+        browserFlowOnly: omitExecuteHttp,
+        payloadFieldNames,
+    });
+    const isReservedByApplicantContactSchema = (name) => usesApplicantContactSchema && applicantContactFieldNames.has(canonicalPayloadField(name));
     // A missing inputBody, or one with no ApplicantContactSchema evidence,
     // means this is not a job-application submission flow. The former keeps
     // its own read-flow `{ query }` contract untouched; the latter (a body WAS
@@ -11447,7 +11980,7 @@ function emitContractTs(opts) {
     // the other sources unchanged.
     const basePayloadSchemaExpr = usesApplicantContactSchema
         ? `ApplicantContactSchema`
-        : inputBody
+        : inputBody || (omitExecuteHttp && isSubmissionFlow)
             ? `z.object({})`
             : `z.object({\n  query: z.string().min(1),\n})`;
     // Only the single-endpoint read path (a real primary operation, no
@@ -11563,11 +12096,16 @@ function emitContractTs(opts) {
     // as required strings (z.email() for Email per the repo's z.string().email()→
     // z.email() migration) so those references typecheck in the generated flow.
     if (payloadFieldNames) {
-        for (const name of [...payloadFieldNames].sort()) {
+        // The browser-flow-only emit canonicalises its own splices already; this
+        // covers a caller handing over vocabulary-row names directly, so one never
+        // becomes a required key beside the base schema's own equivalent.
+        const canonicaliseNames = usesApplicantContactSchema;
+        for (const rawName of [...payloadFieldNames].sort()) {
+            const name = canonicaliseNames ? canonicalPayloadField(rawName) : rawName;
             if (isReservedByApplicantContactSchema(name))
                 continue;
             const zod = name === "Email" ? "z.email()" : "z.string()";
-            const suffix = optionalPayloadFieldNames.has(name) ? ".optional()" : "";
+            const suffix = optionalPayloadFieldNames.has(rawName) ? ".optional()" : "";
             addExtendField(name, `  ${name}: ${zod}${suffix},`);
         }
     }
@@ -11778,7 +12316,12 @@ function emitContractTs(opts) {
         extendFields.set(fieldName, `  ${key}: ${zod}${optional ? ".optional()" : ""},`);
     }
     const mergedExtension = extendFields.size > 0 ? `.extend({\n${[...extendFields.values()].join("\n")}\n})` : "";
-    const payloadSchemaExpr = `${basePayloadSchemaExpr}${mergedExtension}`;
+    // zod strips unknown keys, so without composing it a job-application
+    // contract drops the TrackingUrl the engine's fireTrackingClick reads. merge
+    // rather than a second extend keeps the schema to a single `.extend()`.
+    const composesJobTracking = usesApplicantContactSchema && !extendFields.has("TrackingUrl");
+    const trackingMerge = composesJobTracking ? ".merge(JobTrackingSchema)" : "";
+    const payloadSchemaExpr = `${basePayloadSchemaExpr}${mergedExtension}${trackingMerge}`;
     // basePayloadSchemaExpr's own Answers field always wraps in
     // multipartJsonObject() for job-application submission flows
     // (usesApplicantContactSchema); multipartBoolean() is only imported when a
@@ -11798,6 +12341,9 @@ function emitContractTs(opts) {
     // ApplicantContactSchema backs the job-application submission-flow payload
     // schema (see basePayloadSchemaExpr above); only referenced when
     // usesApplicantContactSchema is true.
+    const jobTrackingImport = composesJobTracking
+        ? `import { JobTrackingSchema } from "${ENGINE_PKG}/lib/job-tracking";\n`
+        : "";
     const applicantContactImport = usesApplicantContactSchema
         ? `import { ApplicantContactSchema } from "${ENGINE_PKG}/lib/applicant-payload";\n`
         : "";
@@ -11878,7 +12424,9 @@ const httpClient = createHttpClient({ schema: ${pascal}ResponseSchema, bottlenec
     // the same captured request-variables object the signal was itself
     // detected from (see paginationOperationIdentity above) — the default
     // `{ q: payload.query }` REST body has no skip/count container to advance.
-    const navigateToFacets = resolveRecurringNavigateToFacets(extractNavigateToFacetOrder(contractFlowSteps), actionSteps);
+    // A single-primary flow compiles no action steps, so its captured traffic
+    // is the only place a declared facet's kind-suffixed element can be found.
+    const navigateToFacets = resolveRecurringNavigateToFacets(extractNavigateToFacetOrder(contractFlowSteps, process.env), actionSteps.length > 0 ? actionSteps : allCaptures.map((capture) => ({ capture })));
     const gqlVariablesExpr = gqlOperationName
         ? renderGqlVariablesExpr(gqlVariables, payloadFieldNames, optionalPayloadFieldNames, navigateToFacets)
         : paginationSignal
@@ -12266,6 +12814,19 @@ const limiter = new Bottleneck({ minTime: ${minTime} });
 ${executeHttpBody}
   },
 `;
+    // Applicant contracts enter on payload.ClickUrl, so a browser-flow-only
+    // execute has nothing left to read from the context.
+    const executeOmitsContext = omitExecuteHttp && usesApplicantContactSchema;
+    const executeContextParam = executeOmitsContext ? "" : `,\n    context: SitePluginContext`;
+    const sitePluginImports = executeOmitsContext
+        ? "SitePlugin, SitePluginResult"
+        : "SitePlugin, SitePluginContext, SitePluginResult";
+    const executeDocComment = omitExecuteHttp
+        ? ""
+        : `  /** Browser fallback: Stagehand + Steel — invoked only when hot path fails. */\n`;
+    const maxAttemptsLiteral = createsAccount
+        ? `\n    // A retry would re-register the same account the first attempt created.\n    maxAttempts: 1,`
+        : "";
     const pluginDocComment = omitExecuteHttp
         ? `/**
  * Plugin for ${siteId}. Browser-flow-only: the captured multi-step submission
@@ -12283,9 +12844,9 @@ ${executeHttpBody}
 
 ${bottleneckImport}import { z } from "zod/v4";
 
-${fixtureImport}${applicantContactImport}${caseInsensitiveHeadersImport}${mergeFoldedPrimaryBodiesImport}${multipartBoolImport}${clientImport}
+${fixtureImport}${applicantContactImport}${jobTrackingImport}${caseInsensitiveHeadersImport}${mergeFoldedPrimaryBodiesImport}${multipartBoolImport}${clientImport}
 import type { BrowserSession } from "${ENGINE_PKG}/scraper/session";
-import type { SitePlugin, SitePluginContext, SitePluginResult } from "${ENGINE_PKG}/site-plugin";
+import type { ${sitePluginImports} } from "${ENGINE_PKG}/site-plugin";
 import { run${pascal}BrowserFlow } from "@/sites/${siteId}/flows/browser-flow";
 ${baseHeadersBlock}${limiterBlock}
 export const ${pascal}ResponseSchema = ${responseSchemaExpr};
@@ -12315,14 +12876,12 @@ export const ${camel}Plugin: SitePlugin<${pascal}Payload, ${pascal}Response> = {
     // since the multipart wire format is what makes that field's
     // JSON-stringified encoding parseable.
     `
-        : ""}apiVersion: ${JSON.stringify(plugin_api_version_1.PLUGIN_API_VERSION)},${payloadNeedsMultipart || usesApplicantContactSchema || hasMultipartStep ? "\n    multipart: true," : ""}${browserFallbackGateLiteral}
+        : ""}apiVersion: ${JSON.stringify(plugin_api_version_1.PLUGIN_API_VERSION)},${payloadNeedsMultipart || usesApplicantContactSchema || hasMultipartStep ? "\n    multipart: true," : ""}${browserFallbackGateLiteral}${maxAttemptsLiteral}
   },
 ${executeHttpMethodBlock}
-  /** Browser fallback: Stagehand + Steel — invoked only when hot path fails. */
-  async execute(
+${executeDocComment}  async execute(
     payload: ${pascal}Payload,
-    session: BrowserSession,
-    context: SitePluginContext
+    session: BrowserSession${executeContextParam}
   ): Promise<SitePluginResult<${pascal}Response>> {
     const raw = await run${pascal}BrowserFlow(session.stagehand, ${usesApplicantContactSchema ? "payload.ClickUrl" : "context.baseUrl"}, payload, session.sessionProxy ?? null);
     return { data: raw as ${pascal}Response };
@@ -12367,6 +12926,108 @@ function assertRequiredUrlFieldsReferenced(contractCode, browserFlowCode) {
     throw new Error(`recon-generate: required URL field(s) ${unreferenced.join(", ")} declared on the payload schema ` +
         `but never referenced by the emitted contract or browser flow — the flow would enter on the wrong page`);
 }
+/**
+ * Blank comments and plain string literals so a `payload.<name>` mention inside
+ * prose or an unrelated string is not mistaken for a read. Template-literal
+ * text is blanked but its `${…}` expressions are kept, because the browser flow
+ * splices fields as `${payload.X}`.
+ */
+function stripNonCodeText(code) {
+    const out = [];
+    // Non-negative: brace depth at which a template literal's text resumes; negative: -(depth+1) of an open `${`.
+    const templateDepths = [];
+    let depth = 0;
+    let i = 0;
+    while (i < code.length) {
+        const ch = code[i];
+        const next = code[i + 1];
+        const inTemplateText = templateDepths.length > 0 && templateDepths[templateDepths.length - 1] === depth;
+        if (inTemplateText) {
+            if (ch === "\\")
+                i += 2;
+            else if (ch === "`") {
+                templateDepths.pop();
+                i++;
+            }
+            else if (ch === "$" && next === "{") {
+                templateDepths.push(-(depth + 1));
+                depth++;
+                out.push("{");
+                i += 2;
+            }
+            else
+                i++;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            while (i < code.length && code[i] !== "\n")
+                i++;
+        }
+        else if (ch === "/" && next === "*") {
+            const end = code.indexOf("*/", i + 2);
+            i = end === -1 ? code.length : end + 2;
+        }
+        else if (ch === '"' || ch === "'") {
+            i++;
+            while (i < code.length && code[i] !== ch && code[i] !== "\n")
+                i += code[i] === "\\" ? 2 : 1;
+            i++;
+            out.push('""');
+        }
+        else if (ch === "`") {
+            templateDepths.push(depth);
+            i++;
+        }
+        else {
+            if (ch === "{")
+                depth++;
+            if (ch === "}") {
+                depth--;
+                if (templateDepths[templateDepths.length - 1] === -(depth + 1))
+                    templateDepths.pop();
+            }
+            out.push(ch ?? "");
+            i++;
+        }
+    }
+    return out.join("");
+}
+/**
+ * Names of the payload fields a flow explicitly declared via `payloadField`
+ * that no emitted request surface reads as `payload.<field>`. The surface is
+ * the emitted contract plus the browser flow: a field only the browser flow
+ * dereferences still changes browser-executed requests, so it counts as
+ * referenced. The schema declaration (`Field: z.…`) is not a `payload.` read,
+ * so it never counts. Vocabulary-derived fields are out of scope. The generator emits the
+ * fields no emitted request reads as optional schema fields, since a required field nothing
+ * sends only burdens callers.
+ */
+function unreferencedDeclaredPayloadFields(contractCode, browserFlowCode, flowSteps) {
+    const emittedCode = `${stripNonCodeText(contractCode)}\n${stripNonCodeText(browserFlowCode)}`;
+    const declared = new Set();
+    for (const step of flowSteps) {
+        if (typeof step !== "string" && step.payloadField)
+            declared.add(step.payloadField);
+    }
+    return [...declared].filter((name) => !new RegExp(`payload\\.${name}(?![\\w$])`).test(emittedCode));
+}
+/**
+ * Declared payload fields the emitted requests never read. When the contract
+ * replays HTTP requests only those count (the browser flow just changes
+ * instruction text); a browser-only contract counts the browser flow too.
+ * These are emitted optional so no caller has to supply a value that nothing
+ * sends.
+ */
+function unreadDeclaredPayloadFields(contractCode, browserFlowCode, flowSteps) {
+    return new Set(unreferencedDeclaredPayloadFields(contractCode, contractCode.includes("httpClient(") ? "" : browserFlowCode, flowSteps));
+}
+/**
+ * Review-checklist lines for declared payload fields no emitted request reads,
+ * so a reviewer sees the silently-optionalized field outside the log stream.
+ */
+function unreadPayloadFieldChecklistLines(fields) {
+    return [...fields].map((field) => `Declared payloadField ${field} is read by no emitted request and was emitted optional — confirm it should affect the request, or drop it`);
+}
 /**
  * Escape a literal string segment so it is safe INSIDE a JS backtick template
  * literal — backslashes, backticks, and `${` interpolation starts must all be
@@ -12386,13 +13047,17 @@ function escapeForTemplateLiteral(segment) {
  * own choice so the browser-flow and HTTP-body emitters never disagree on
  * which quoted span is the persona value.
  */
-function buildStepInstructionExpr(instruction, field) {
+function buildStepInstructionExpr(instruction, field, capturedFallback = false) {
     if (field === null)
         return JSON.stringify(instruction);
     const site = locateSpliceSite(instruction);
     if (site === null)
         return JSON.stringify(instruction);
-    return `\`${escapeForTemplateLiteral(site.before)}\${payload.${field}}${escapeForTemplateLiteral(site.after)}\``;
+    const captured = pickedQuotedValue(instruction);
+    const read = capturedFallback && captured !== null
+        ? `payload.${field} ?? ${JSON.stringify(captured)}`
+        : `payload.${field}`;
+    return `\`${escapeForTemplateLiteral(site.before)}\${${read}}${escapeForTemplateLiteral(site.after)}\``;
 }
 /**
  * Build the emitted instruction expression for a step whose value is the
@@ -12459,6 +13124,22 @@ function jsonSchemaTypeOf(value) {
         return "object";
     return "string";
 }
+/**
+ * Whether the flow's last step declares itself non-submit in its own wording
+ * (and carries no explicit `submitStep` flag). The submission-flow forcing must
+ * skip it: an explicit flag overrides declared intent at runtime, so forcing it
+ * onto a trailing guardrail step would route that step through the submit judge.
+ */
+function lastFlowStepDeclaresNonSubmit(flowSteps) {
+    const last = flowSteps.at(-1);
+    if (last === undefined)
+        return false;
+    const isObj = typeof last !== "string";
+    return (0, flow_runner_1.isStepDeclaredNonSubmit)({
+        step: isObj ? last.step : last,
+        submitStep: isObj ? last.submitStep === true : false,
+    });
+}
 /**
  * Emits a config-only plugin manifest (`<siteId>.plugin.json`) from the recon
  * flow, as an alternative to the `.ts` trio for browser-only sites. Reuses the
@@ -12478,9 +13159,18 @@ function jsonSchemaTypeOf(value) {
  * browser `flow` is the only execution path, and the field is omitted.
  */
 function emitConfigManifest(opts) {
-    const { siteId, displayName, baseUrl, flowSteps, vocabulary, inputBody, recoveredFields, httpModulePath, isSubmissionFlow = false, env = process.env, } = opts;
+    const { siteId, displayName, baseUrl, flowSteps, vocabulary, inputBody, recoveredFields, httpModulePath, isSubmissionFlow = false, hasMultipartStep = false, browserFlowOnly = false, env = process.env, } = opts;
+    // Raw (uncanonicalised) splice names are the evidence for a body-less flow;
+    // the decision must be made on them before canonicalising, or it is circular.
+    const canonicalise = contractUsesApplicantContactSchema({
+        inputBody,
+        isSubmissionFlow,
+        browserFlowOnly,
+        payloadFieldNames: computeFlowPayloadFieldNames(flowSteps, vocabulary, env, false)
+            .payloadFieldNames,
+    });
     const payloadFieldNames = new Set();
-    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env);
+    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env, canonicalise);
     const steps = flowSteps.map((step) => {
         const isObj = typeof step !== "string";
         const instruction = isObj ? step.step : step;
@@ -12507,7 +13197,7 @@ function emitConfigManifest(opts) {
                 ...(emailStep ? { emailStep, emailStepConfig: emailStepConfig ?? {} } : {}),
             };
         }
-        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues);
+        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues, canonicalise);
         if (field !== null)
             payloadFieldNames.add(field);
         const rewritten = buildManifestInstruction(instruction, field);
@@ -12532,7 +13222,7 @@ function emitConfigManifest(opts) {
     // load of this manifest also gates on runHealingFlow's submitStep verification.
     const lastStepIndex = steps.length - 1;
     const lastStep = steps[lastStepIndex];
-    if (isSubmissionFlow && lastStep !== undefined) {
+    if (isSubmissionFlow && lastStep !== undefined && !lastFlowStepDeclaresNonSubmit(flowSteps)) {
         steps[lastStepIndex] =
             typeof lastStep === "string"
                 ? { step: lastStep, optional: false, upload: false, submitStep: true }
@@ -12557,9 +13247,24 @@ function emitConfigManifest(opts) {
             requestProperties[name] = { type: jsonSchemaTypeOf(value) };
         }
     }
+    const usesApplicantContactSchema = contractUsesApplicantContactSchema({
+        inputBody,
+        isSubmissionFlow,
+        browserFlowOnly,
+        payloadFieldNames,
+    });
+    // Mirrors the .ts contract's JobTrackingSchema composition: a request schema
+    // without it would drop the TrackingUrl the engine reads after submission.
+    if (usesApplicantContactSchema)
+        requestProperties.TrackingUrl ??= { type: "string" };
     const sortedRequestProperties = Object.fromEntries(Object.keys(requestProperties)
         .sort()
         .map((name) => [name, requestProperties[name]]));
+    // Same decision emitBrowserFlowTs makes: only a flow that uploads AND whose
+    // contract carries Resume fields is multipart, so buildUploadFixture agrees.
+    const hasUploadStep = flowSteps.some((s) => typeof s !== "string" && s.upload === true);
+    const contractCarriesResume = hasMultipartStep || usesApplicantContactSchema;
+    const multipart = hasUploadStep && contractCarriesResume;
     const manifest = {
         apiVersion: plugin_manifest_envelope_1.CONFIG_PLUGIN_API_VERSION,
         kind: plugin_manifest_envelope_1.CONFIG_PLUGIN_KIND,
@@ -12567,6 +13272,7 @@ function emitConfigManifest(opts) {
         spec: {
             defaultBaseUrl: baseUrl,
             ...(httpModulePath ? { httpModule: httpModulePath } : {}),
+            ...(multipart ? { multipart: true } : {}),
             request: { type: "object", properties: sortedRequestProperties },
             response: {
                 type: "object",
@@ -12601,7 +13307,7 @@ function emitConfigManifest(opts) {
  * facet-splice pass can correlate against the exact same declared field set
  * instead of re-deriving a second, potentially-drifting one.
  */
-function computeFlowPayloadFieldNames(flowSteps, vocabulary, env) {
+function computeFlowPayloadFieldNames(flowSteps, vocabulary, env, canonicalise = false) {
     const payloadFieldNames = new Set();
     // Widest wins: a field is only optional if EVERY step that registers it
     // does so as optional.
@@ -12615,7 +13321,7 @@ function computeFlowPayloadFieldNames(flowSteps, vocabulary, env) {
             optionalPayloadFieldNames.delete(field);
         }
     };
-    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env);
+    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env, canonicalise);
     for (const step of flowSteps) {
         const isObj = typeof step !== "string";
         const instruction = isObj ? step.step : step;
@@ -12642,7 +13348,7 @@ function computeFlowPayloadFieldNames(flowSteps, vocabulary, env) {
             continue;
         if (instruction.includes(RECON_PASSWORD_TOKEN))
             continue;
-        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues);
+        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues, canonicalise);
         const composite = field === null && !(isObj && step.payloadFieldNone)
             ? resolveCompositePersonaFields(instruction, knownFieldValues)
             : null;
@@ -12665,10 +13371,22 @@ function computeFlowPayloadFieldNames(flowSteps, vocabulary, env) {
     return { payloadFieldNames, optionalPayloadFieldNames };
 }
 function emitBrowserFlowTs(opts) {
-    const { siteId, pascal, flowSteps, isSubmissionFlow, hasMultipartStep = false, vocabulary, frameSelector, env = process.env, } = opts;
-    const { payloadFieldNames, optionalPayloadFieldNames } = computeFlowPayloadFieldNames(flowSteps, vocabulary, env);
+    const { siteId, pascal, flowSteps, isSubmissionFlow, hasMultipartStep = false, browserFlowOnly = false, inputBody, vocabulary, frameSelector, capturedFallbackFields = new Set(), env = process.env, } = opts;
+    const canonicalise = contractUsesApplicantContactSchema({
+        inputBody,
+        isSubmissionFlow,
+        browserFlowOnly,
+        payloadFieldNames: computeFlowPayloadFieldNames(flowSteps, vocabulary, env, false)
+            .payloadFieldNames,
+    });
+    const { payloadFieldNames, optionalPayloadFieldNames } = computeFlowPayloadFieldNames(flowSteps, vocabulary, env, canonicalise);
+    for (const field of capturedFallbackFields) {
+        if (payloadFieldNames.has(field))
+            optionalPayloadFieldNames.add(field);
+    }
     const hasUploadStep = flowSteps.some((s) => typeof s !== "string" && s.upload === true);
-    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env);
+    const contractCarriesResume = hasMultipartStep || canonicalise;
+    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env, canonicalise);
     let usesThrowawayPassword = false;
     let usesEmailStep = false;
     const stepLiterals = flowSteps.map((step) => {
@@ -12710,14 +13428,14 @@ function emitBrowserFlowTs(opts) {
             const submitStep = isObj ? step.submitStep === true : false;
             return `  { instruction: ${instructionExpr}, optional: ${optional}, upload: ${upload}, submitStep: ${submitStep} },`;
         }
-        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues);
+        const field = resolveStepPayloadField(instruction, isObj ? step.payloadField : undefined, isObj ? step.payloadFieldNone : undefined, vocabulary, knownFieldValues, canonicalise);
         const composite = field === null && !(isObj && step.payloadFieldNone)
             ? resolveCompositePersonaFields(instruction, knownFieldValues)
             : null;
         const optional = isObj ? step.optional === true : false;
         const instructionExpr = composite !== null
             ? buildCompositeStepInstructionExpr(instruction, composite.fieldA, composite.fieldB)
-            : buildStepInstructionExpr(instruction, field);
+            : buildStepInstructionExpr(instruction, field, field !== null && capturedFallbackFields.has(field));
         const upload = isObj ? step.upload === true : false;
         const submitStep = isObj ? step.submitStep === true : false;
         return `  { instruction: ${instructionExpr}, optional: ${optional}, upload: ${upload}, submitStep: ${submitStep} },`;
@@ -12726,7 +13444,9 @@ function emitBrowserFlowTs(opts) {
     // submitStep:true even when the source recon-flow.json step never declared
     // it, so the engine's pre-submit probe/StepVerificationError actually gates it.
     const lastStepLiteral = stepLiterals.at(-1);
-    if (isSubmissionFlow && lastStepLiteral !== undefined) {
+    if (isSubmissionFlow &&
+        lastStepLiteral !== undefined &&
+        !lastFlowStepDeclaresNonSubmit(flowSteps)) {
         stepLiterals[stepLiterals.length - 1] = lastStepLiteral.replace(/submitStep: (true|false)(?= \},)/, "submitStep: true");
     }
     const flowStepsBlock = stepLiterals.length > 0
@@ -12741,7 +13461,7 @@ function emitBrowserFlowTs(opts) {
     // multipart detection is dropped), those payload fields don't exist yet — emit
     // a null + TODO so the generated module still typechecks; the operator adds
     // the multipart contract fields and wires the fixture during hand-finish.
-    const uploadFixtureExpr = hasUploadStep && hasMultipartStep
+    const uploadFixtureExpr = hasUploadStep && contractCarriesResume
         ? `{
     buffer: Buffer.from(payload.Resume),
     name: payload.ResumeFilename ?? "resume.pdf",
@@ -12797,8 +13517,8 @@ export async function run${pascal}BrowserFlow(
 ): Promise<${pascal}Response> {
   const page = await stagehand.context.awaitActivePage();
 
-  await page.goto(${isSubmissionFlow ? "entryUrl" : "baseUrl"}, { waitUntil: "networkidle" });
-  // networkidle can resolve before a bot-managed/CDN-fronted SPA hydrates; wait for
+  await page.goto(${isSubmissionFlow ? "entryUrl" : "baseUrl"}, { waitUntil: "domcontentloaded" });
+  // domcontentloaded fires before a bot-managed/CDN-fronted SPA hydrates; wait for
   // the real DOM so the first steps don't probe an empty shell page and skip.
   await waitForSpaReady(page, logger);
 ${usesThrowawayPassword ? "\n  // Minted once per run — the flow needs a credential to authenticate, but\n  // there is no caller-supplied Password field on the payload to splice.\n  const throwawayPassword = generateThrowawayPassword();\n" : ""}${usesEmailStep ? "\n  // Resolved once per run from the caller-supplied Email — the emailStep hook\n  // polls this inbox rather than a freshly allocated one, since the applicant\n  // (not this run) owns the address the ATS actually emails.\n  const allocatedInbox = testmailInboxFromAddress(payload.Email);\n" : ""}
@@ -12855,7 +13575,7 @@ ${flowStepsBlock}
 }
 `}`;
     assertNoLeakedPersonaConstant(code, knownFieldValues);
-    return { code, payloadFieldNames, optionalPayloadFieldNames };
+    return { code, payloadFieldNames, optionalPayloadFieldNames, usesThrowawayPassword };
 }
 /** Generates the site's index.ts barrel — exported so the out-of-tree e2e
  * test can drive the emitter directly without spawning the CLI. */
@@ -13235,6 +13955,7 @@ async function main() {
             };
         }
     })();
+    const browserFlowOnlyOptIn = (0, node_fs_1.existsSync)(flowFile) ? (0, recon_shared_1.readBrowserFlowOnly)(flowFile) : false;
     // Flow-declared signals that isolate the submission POSTs from same-origin
     // page chrome. Threaded into action-sequence extraction and header derivation
     // so both draw from the real submission, not incidental widget/chatbot POSTs.
@@ -13271,7 +13992,15 @@ async function main() {
      * already written its output and there is nothing left for main() to do.
      */
     function generateFromCaptures(activeCaptures) {
-        const baseUrl = deriveBaseUrl(activeCaptures, ownBackendHostnames, submitPatterns);
+        if (activeCaptures.length === 0 && !allowEmptyCapture) {
+            throw new Error("empty capture pool: no captures remain to derive a base URL from (a placeholder origin would leak into the contract)");
+        }
+        // An opted-in empty capture has no origin to derive; "" leaves the
+        // operator's siteBaseUrls config as the only source instead of a
+        // placeholder origin leaking into the contract.
+        const baseUrl = activeCaptures.length === 0
+            ? ""
+            : deriveBaseUrl(activeCaptures, ownBackendHostnames, submitPatterns);
         // Gate on the flow's declared own-backend hosts (or the registrable-domain
         // fallback of baseUrl) via the same predicate recon-http.ts applies at
         // write time, so a stale aux/ directory from before that filter existed
@@ -13417,7 +14146,7 @@ async function main() {
             logger.warn(`submission selection: declared submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) disagrees with the unfiltered heuristic action sequence (${unfilteredHeuristicActionCaptures.length} capture(s)); using the declared pattern because requireSubmitEndpointMatch is set`);
         }
         else if (patternUndercounts) {
-            logger.info(`submission selection: ignoring submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) as an undercount of the unfiltered heuristic action sequence (${unfilteredHeuristicActionCaptures.length} capture(s))`);
+            logger.info(`submission selection: using declared submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) although the unfiltered heuristic action sequence finds ${unfilteredHeuristicActionCaptures.length} capture(s); the unfiltered set would make the generator attempt an HTTP replay that aborts on frozen-varying fields`);
         }
         const heuristicActionCaptures = patternedHeuristicActionCaptures;
         const manifestActionCaptures = resolveManifestActionSequence(runRoot, activeCaptures);
@@ -13508,7 +14237,12 @@ async function main() {
             ? indexStateValues(activeCaptures, shieldedUuids, actionCaptureIndices, dependentDrillDownChainValues)
             : new Map();
         const actionSteps = actionCaptures.length > 1 ? compileActionSteps(actionCaptures, stateIndex) : [];
-        const isSubmissionFlow = actionSteps.length > 1 && (!gql || graphqlActionSequenceHasMutation);
+        // A multi-step flow whose declared submit pattern selects no captures has no
+        // replayable HTTP sequence, yet is still not a search: treat it as a
+        // browser-flow-only submission flow rather than the single-endpoint `{query}` branch.
+        const noReplayableActionFlow = !gql && actionSteps.length === 0 && flowSteps.length > 1;
+        const isSubmissionFlow = noReplayableActionFlow ||
+            (actionSteps.length > 1 && (!gql || graphqlActionSequenceHasMutation));
         // Diagnostic for the FAILURE-3 shape (a flowless recon capture): a "submission flow"
         // whose every action capture is landing-phase is almost certainly page-chrome
         // bootstrap (e.g. page-chrome `POST /widgets`) misread as an apply flow, not a walked
@@ -13610,7 +14344,8 @@ async function main() {
         // downgrade to the single-endpoint `{query}` branch either, since that's a
         // fabrication of its own kind for a flow that isn't a single-action
         // query/search to begin with.
-        const browserFlowOnly = isSubmissionFlow && actionSteps.some((s) => s.isCrossDomain);
+        const browserFlowOnly = isSubmissionFlow &&
+            (browserFlowOnlyOptIn || noReplayableActionFlow || actionSteps.some((s) => s.isCrossDomain));
         const multiStepBody = browserFlowOnly
             ? undefined
             : isSubmissionFlow
@@ -13678,7 +14413,7 @@ async function main() {
         if (foldReturnSpec !== null && effectiveFoldPlanCount > 0 && !declaredJoinFieldsApplied) {
             logger.warn(`flow declares foldReturn (endpointPattern: ${foldReturnSpec.endpointPattern}, resultsPath: ${foldReturnSpec.resultsPath}, joinFields: ${foldReturnSpec.joinFields.join(", ")}) but the declared spec resolved no fold plan — only structurally-detected fold plans (with their own guessed join fields) were emitted, so the declared joinFields were not applied; check that the endpointPattern names a capture in the action sequence and resultsPath resolves on the primary response`);
         }
-        logger.info(`generating plugin for ${siteId} (${gql ? "GraphQL" : browserFlowOnly ? `submission flow, ${actionSteps.length} steps, browser-flow-only (cross-domain hop detected)` : isSubmissionFlow ? `submission flow, ${actionSteps.length} steps` : "single-endpoint REST"}, baseUrl: ${baseUrl})`);
+        logger.info(`generating plugin for ${siteId} (${gql ? "GraphQL" : browserFlowOnly ? `submission flow, ${actionSteps.length} steps, browser-flow-only (${browserFlowOnlyOptIn ? "forced by flow file" : noReplayableActionFlow ? "no replayable action sequence" : "cross-domain hop detected"})` : isSubmissionFlow ? `submission flow, ${actionSteps.length} steps` : "single-endpoint REST"}, baseUrl: ${baseUrl})`);
         if (emit === "config") {
             (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
             (0, node_fs_1.writeFileSync)(manifestPath, emitConfigManifest({
@@ -13690,6 +14425,8 @@ async function main() {
                 inputBody,
                 recoveredFields: [...discoveredFormFields, ...discoveredOptionFields],
                 isSubmissionFlow,
+                hasMultipartStep,
+                browserFlowOnly,
                 // A submission flow is the case where the `.ts` emit carries an
                 // executeHttp hot path; point the manifest at where the operator drops
                 // the compiled module rather than silently dropping the direct path.
@@ -13712,6 +14449,8 @@ async function main() {
             flowSteps,
             isSubmissionFlow,
             hasMultipartStep,
+            browserFlowOnly,
+            inputBody,
             vocabulary,
             frameSelector,
         });
@@ -13750,6 +14489,7 @@ async function main() {
             auxFiles,
             multiStepBody,
             omitExecuteHttp: browserFlowOnly,
+            createsAccount: browserFlow.usesThrowawayPassword,
             isSubmissionFlow,
             inputBody,
             hasMultipartStep,
@@ -13769,11 +14509,43 @@ async function main() {
             unpopulatedDeclaredVariables: primaryGraphQLOperation?.unpopulatedDeclaredVariables ?? [],
             fallbackGateSpec,
         };
-        const contractCode = emitContractTs(contractOpts);
+        const firstContractCode = emitContractTs(contractOpts);
+        const unread = unreadDeclaredPayloadFields(firstContractCode, browserFlow.code, flowSteps);
+        // A field no emitted request reads must not be required of callers. The
+        // browser fallback keeps splicing it, from the captured value when the
+        // caller omits it, so the field still takes effect when supplied.
+        const settled = unread.size === 0
+            ? { browserFlow, contractOpts, contractCode: firstContractCode }
+            : (() => {
+                const fallbackBrowserFlow = emitBrowserFlowTs({
+                    siteId,
+                    pascal,
+                    baseUrl,
+                    flowSteps,
+                    isSubmissionFlow,
+                    hasMultipartStep,
+                    browserFlowOnly,
+                    vocabulary,
+                    frameSelector,
+                    capturedFallbackFields: unread,
+                });
+                const optionalized = {
+                    ...contractOpts,
+                    optionalPayloadFieldNames: new Set([
+                        ...fallbackBrowserFlow.optionalPayloadFieldNames,
+                        ...unread,
+                    ]),
+                };
+                return {
+                    browserFlow: fallbackBrowserFlow,
+                    contractOpts: optionalized,
+                    contractCode: emitContractTs(optionalized),
+                };
+            })();
         return {
-            contractCode,
-            contractOpts,
-            browserFlow,
+            contractCode: settled.contractCode,
+            contractOpts: settled.contractOpts,
+            browserFlow: settled.browserFlow,
             auxFiles,
             resolvedPool: actionCaptures,
             isSubmissionFlow,
@@ -13785,11 +14557,18 @@ async function main() {
     if (result === null)
         return; // emit === "config": already written above.
     const final = healUnreferencedUrlFieldsOnce(captures, result, generateFromCaptures);
+    const unreferencedEverywhere = new Set(unreferencedDeclaredPayloadFields(final.contractCode, final.browserFlow.code, flowSteps));
+    for (const field of unreadDeclaredPayloadFields(final.contractCode, final.browserFlow.code, flowSteps)) {
+        logger.warn(`declared payloadField ${field} is read by no emitted request; emitted as optional schema field${unreferencedEverywhere.has(field) ? "" : " (only the browser flow splices it)"}`);
+    }
     (0, node_fs_1.writeFileSync)(`${outDir}/contract.ts`, final.contractCode);
     logger.info(`wrote ${outDir}/contract.ts`);
     // Same opts fed to emitContractTs above, so this can never drift from what
     // the header used to embed.
-    const checklist = buildContractChecklist(final.contractOpts);
+    const checklist = [
+        ...buildContractChecklist(final.contractOpts),
+        ...unreadPayloadFieldChecklistLines(unreadDeclaredPayloadFields(final.contractCode, final.browserFlow.code, flowSteps)),
+    ];
     logger.info(`review checklist for ${outDir}/contract.ts:\n${checklist.map((item) => `  [ ] ${item}`).join("\n")}`);
     (0, node_fs_1.writeFileSync)(`${outDir}/flows/browser-flow.ts`, final.browserFlow.code);
     logger.info(`wrote ${outDir}/flows/browser-flow.ts`);