@enricai/barnacle 1.12.78 → 1.12.80

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,26 +69,34 @@ exports.resolveRecurringNavigateToFacets = resolveRecurringNavigateToFacets;
 exports.emitMultiStepExecuteHttp = emitMultiStepExecuteHttp;
 exports.countSpliceableFacets = countSpliceableFacets;
 exports.spliceFacetsIntoStringVariable = spliceFacetsIntoStringVariable;
+exports.matchFacetRecurrence = matchFacetRecurrence;
 exports.spliceFacetsIntoArrayVariable = spliceFacetsIntoArrayVariable;
 exports.renderGqlVariablesExpr = renderGqlVariablesExpr;
 exports.findAllObjectArrayFields = findAllObjectArrayFields;
 exports.findAllObjectArrayFieldsOrWholeObject = findAllObjectArrayFieldsOrWholeObject;
+exports.collectRequestBodyValuesByKey = collectRequestBodyValuesByKey;
+exports.findFrozenVaryingDrillParams = findFrozenVaryingDrillParams;
 exports.applyDrillParamBindings = applyDrillParamBindings;
 exports.collectResponseLeafValues = collectResponseLeafValues;
 exports.getScanPrimaryCandidateGroupsCallCountForTest = getScanPrimaryCandidateGroupsCallCountForTest;
 exports.resetScanPrimaryCandidateGroupsCallCountForTest = resetScanPrimaryCandidateGroupsCallCountForTest;
 exports.detectDrillDownFoldPlan = detectDrillDownFoldPlan;
 exports.parseFoldReturnSpec = parseFoldReturnSpec;
+exports.parseBrowserFlowOnlyOptIn = parseBrowserFlowOnlyOptIn;
 exports.parseFallbackGateSpec = parseFallbackGateSpec;
+exports.readComparableBodyLeaf = readComparableBodyLeaf;
 exports.collectRequestValuesIncludingHeaders = collectRequestValuesIncludingHeaders;
 exports.getFoldPlanResolutionCallCountForTests = getFoldPlanResolutionCallCountForTests;
 exports.resetFoldPlanResolutionCallCountForTests = resetFoldPlanResolutionCallCountForTests;
 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.buildStepInstructionExpr = buildStepInstructionExpr;
 exports.emitConfigManifest = emitConfigManifest;
 exports.emitBrowserFlowTs = emitBrowserFlowTs;
 exports.emitIndexTs = emitIndexTs;
@@ -106,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");
 /**
@@ -138,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.
@@ -186,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),
     };
 }
 /**
@@ -204,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;
 }
 /**
@@ -251,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)
@@ -264,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).
@@ -283,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
@@ -304,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);
@@ -331,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
@@ -360,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;
 }
 /**
@@ -406,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: [],
+                });
+            }
             continue;
+        }
         const hashIndex = step.navigateTo.indexOf("#");
         const currentHash = hashIndex === -1 ? undefined : step.navigateTo.slice(hashIndex + 1);
         if (step.payloadField) {
@@ -419,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)
@@ -426,6 +504,60 @@ 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));
+}
+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);
 }
@@ -456,7 +588,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)
@@ -479,7 +611,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}`);
         }
@@ -496,16 +628,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);
@@ -531,12 +654,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
@@ -550,10 +683,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) {
@@ -1296,6 +1429,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) {
@@ -1308,7 +1445,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
@@ -3801,11 +3938,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;
@@ -5995,9 +6129,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");
@@ -6044,7 +6183,7 @@ function* walkArrayLeaves(value, path = []) {
  * an `undefined` and no call site renders the array through a different
  * construction. Non-facet elements stay literal.
  */
-function applyArrayFacetSplicePayloadSubstitutions(template, inputBody, navigateToFacets, ownedArrayPathKeys) {
+function applyArrayFacetSplicePayloadSubstitutions(template, inputBody, navigateToFacets, ownedArrayPathKeys, siblingBodies = []) {
     if (navigateToFacets.length === 0)
         return template;
     if (inputBody === null || typeof inputBody !== "object")
@@ -6057,11 +6196,73 @@ function applyArrayFacetSplicePayloadSubstitutions(template, inputBody, navigate
             !containsFacetArray(value, navigateToFacets)) {
             continue;
         }
-        const expression = renderFacetValueExpression(value, navigateToFacets);
+        const absentFacets = collectSiblingArrayFacets(value, path, siblingBodies, navigateToFacets);
+        const absentFields = new Set(absentFacets.map(({ facet }) => facet.field));
+        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
+ * capture per item, so a facet only a dropped sibling's differently shaped
+ * array carried would otherwise never reach the emitted body. Each facet is
+ * taken once, at its first occurrence, and only for facets `own` leaves out.
+ */
+function collectSiblingArrayFacets(own, path, siblingBodies, facets) {
+    const present = new Set(own.flatMap((element) => typeof element === "string" ? [matchArrayElementFacet(element, facets)?.field] : []));
+    const key = arrayPathKey(path);
+    const absent = [];
+    for (const body of siblingBodies) {
+        if (body === null || typeof body !== "object")
+            continue;
+        for (const { value, path: siblingPath } of walkArrayLeaves(body)) {
+            if (arrayPathKey(siblingPath) !== key)
+                continue;
+            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,
+                    before: value.slice(0, index),
+                    after: value.slice(index + 1),
+                });
+            }
+        }
+    }
+    return absent;
+}
 /** Whether `value` is, or contains at any depth, an array with a
  * facet-bearing string element. */
 function containsFacetArray(value, facets) {
@@ -6460,6 +6661,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) {
@@ -6552,9 +6763,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) {
@@ -6575,22 +6788,45 @@ 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 aliased = declared.flatMap((facet) => {
+        const literal = findKindKeyedLiteral(facet, actions);
+        if (literal === undefined || declared.some(({ value }) => value === literal))
+            return [];
+        if (claimedLiterals.has(literal))
+            return [];
+        claimedLiterals.add(literal);
+        const known = [facet.value, ...(facet.literals ?? [])];
+        if (known.some((candidate) => candidate.toLowerCase() === literal.toLowerCase()))
+            return [];
+        const valueMap = new Map(facet.value.length > 0 ? [[facet.value, literal]] : []);
+        return [{ ...facet, value: literal, literals: [literal], keyedByKind: true, valueMap }];
+    });
+    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 [];
@@ -6598,7 +6834,50 @@ function resolveRecurringNavigateToFacets(declared, actions) {
             return [];
         return bindsWithoutCollisionIn(bodies, diffed) ? [{ ...facet, value: diffed }] : [];
     });
-    return [...resolvedDeclared, ...extras];
+    return [...withAliases, ...extras];
+}
+/**
+ * The literal 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.
+ * Returns `undefined` unless exactly one distinct literal carries the kind.
+ */
+function findKindKeyedLiteral(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 && closest.size === 1)
+        return [...closest][0];
+    const sameMonthInKind = [...(closest ?? sameMonth)].filter((literal) => sameMonth.has(literal));
+    return sameMonthInKind.length === 1 ? sameMonthInKind[0] : undefined;
 }
 /**
  * Resolves each zero-recurrence navigateTo facet (in flow order) to the real
@@ -6683,7 +6962,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) {
@@ -6959,6 +7238,21 @@ flowSteps = [], vocabulary = undefined) {
     // `foldReturnSpec`, not on Pass 1's render) so Pass 1 knows which values to
     // spare per step, mirroring the header-name collection above.
     const joinFieldValuesByStep = new Map();
+    // Request bodies of the absorbed repeat captures of each fold target's
+    // representative drill (see FoldPlan.absorbedIndices): never emitted
+    // themselves, so a facet only their differently shaped arrays carry must be
+    // threaded through the representative's body instead of being dropped.
+    const absorbedSiblingBodiesByStep = new Map();
+    for (const plan of earlyFoldPlans) {
+        for (const target of plan.targets) {
+            const drillEndpoint = endpointKey(actions[target.drillStepIndex].capture.url);
+            const siblings = plan.absorbedIndices
+                .map((index) => actions[index].capture)
+                .filter((capture) => endpointKey(capture.url) === drillEndpoint)
+                .map((capture) => parseJsonBodyOrNull(capture.requestPostData));
+            absorbedSiblingBodiesByStep.set(target.drillStepIndex, siblings);
+        }
+    }
     for (const plan of earlyFoldPlans) {
         const primaryItems = objectItemsAtPath(actions[plan.primaryStepIndex].capture.responseBody, plan.primaryArrayPath);
         for (const target of plan.targets) {
@@ -7074,7 +7368,7 @@ flowSteps = [], vocabulary = undefined) {
         // unparameterized structured value — see
         // {@link applyArrayFacetSplicePayloadSubstitutions}.
         const rawBodyWithOptionalArrayFacetSplices = parsedBody !== null
-            ? applyArrayFacetSplicePayloadSubstitutions(rawBodyWithFacetSplices, parsedBody, navigateToFacetOrder, facetArrayPathKeys)
+            ? applyArrayFacetSplicePayloadSubstitutions(rawBodyWithFacetSplices, parsedBody, navigateToFacetOrder, facetArrayPathKeys, absorbedSiblingBodiesByStep.get(i))
             : rawBodyWithFacetSplices;
         const rawBodyWithScalarFacetSplices = parsedBody !== null
             ? applyScalarFacetSplicePayloadSubstitutions(rawBodyWithOptionalArrayFacetSplices, parsedBody, navigateToFacetOrder)
@@ -8031,17 +8325,157 @@ 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;
+}
+/**
+ * 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
@@ -8054,8 +8488,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;
@@ -8077,7 +8515,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) {
@@ -8120,7 +8558,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;
@@ -8506,7 +8944,7 @@ function collectRequestBodyValuesByKey(capture, allCaptures) {
                 const otherBody = parsedRequestBodyFor(c);
                 if (otherBody === undefined)
                     return undefined;
-                const otherValue = readValueAtPath(otherBody, path);
+                const otherValue = readComparableBodyLeaf(parsedBody, otherBody, path);
                 return otherValue === undefined ? undefined : String(otherValue);
             }
             catch {
@@ -8552,29 +8990,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 = readValueAtPath(body, path);
+            const fieldRaw = readComparableBodyLeaf(parsedBody, body, path);
             if (fieldRaw === undefined)
                 continue;
-            const siblingRaw = readValueAtPath(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);
@@ -8584,10 +9029,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
@@ -8671,7 +9114,7 @@ function findFrozenVaryingDrillParams(capture, renderedText, allCaptures) {
                 continue;
             const fieldPath = path.join(".");
             const differing = otherBodies
-                .map((otherBody) => readValueAtPath(otherBody, path))
+                .map((otherBody) => readComparableBodyLeaf(parsedBody, otherBody, path))
                 .find((v) => v !== undefined && String(v) !== stringValue);
             if (differing !== undefined &&
                 !isExplainedByCorrelatedSiblingField(path, parsedBody, otherBodies, new Set(allPaths.filter((p) => p !== fieldPath)))) {
@@ -9570,6 +10013,23 @@ function parseFoldReturnSpec(flowFileContents) {
         return null;
     }
 }
+/**
+ * Reads the flow file's `browserFlowOnly: true` opt-in, which forces the
+ * browser-flow-only emit for a submission flow whose HTTP analysis would
+ * otherwise produce an executeHttp path. Anything but a literal `true` (or an
+ * unreadable/legacy bare-array file) is "not opted in".
+ */
+function parseBrowserFlowOnlyOptIn(flowFileContents) {
+    try {
+        const raw = JSON.parse(flowFileContents);
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+            return false;
+        return raw.browserFlowOnly === true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Parses `browserFallbackGate`/`httpTimeoutMs` out of an object-form
  * recon-flow.json, mirroring {@link parseFoldReturnSpec}'s null-safe pattern:
@@ -9649,6 +10109,108 @@ function readValueAtPath(body, path) {
         return node[segment];
     }, body);
 }
+const ARRAY_ELEMENT_IDENTITY = /^[\s\S]*([^A-Za-z0-9=]\w+=[\s\S]*)$/;
+/** The `<delimiter><name>=<anything>` suffix of a self-describing array element
+ * (the grammar {@link matchArrayElementFacet} binds on), or `undefined`. The
+ * suffix is open-ended because slugs and names carry hyphens, dots and colons
+ * — a stricter shape would silently fall back to index comparison for them. */
+function arrayElementIdentity(element) {
+    if (typeof element !== "string")
+        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.
+ */
+function innermostArrayIndexSegment(body, path) {
+    for (let index = path.length - 1; index >= 0; index--) {
+        if (!/^\d+$/.test(path[index]))
+            continue;
+        if (Array.isArray(readValueAtPath(body, path.slice(0, index))))
+            return index;
+    }
+    return -1;
+}
+/**
+ * Counterpart of the primitive leaf at `path` in `body`, read from `otherBody`.
+ * A string leaf inside an array of self-describing elements (directly, or as a
+ * 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`. 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}.
+ */
+function readComparableBodyLeaf(body, otherBody, path) {
+    const leaf = readValueAtPath(body, path);
+    const arrayEnd = typeof leaf === "string" ? innermostArrayIndexSegment(body, path) : -1;
+    if (arrayEnd === -1)
+        return readValueAtPath(otherBody, path);
+    const arrayPath = path.slice(0, arrayEnd);
+    const elementSubpath = path.slice(arrayEnd + 1);
+    const ownArray = readValueAtPath(body, arrayPath);
+    const otherArray = readValueAtPath(otherBody, arrayPath);
+    const identity = arrayElementIdentity(leaf);
+    const isSelfDescribing = (array) => array.some((element) => arrayElementIdentity(readValueAtPath(element, elementSubpath)));
+    if (identity === undefined &&
+        !isSelfDescribing(ownArray) &&
+        !(Array.isArray(otherArray) && isSelfDescribing(otherArray))) {
+        return readValueAtPath(otherBody, path);
+    }
+    if (!Array.isArray(otherArray))
+        return undefined;
+    const counterparts = otherArray.map((element) => readValueAtPath(element, elementSubpath));
+    if (counterparts.includes(leaf))
+        return leaf;
+    if (identity === undefined)
+        return undefined;
+    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}
  * / `drillResultsPath` into the SAME {@link ARRAY_WILDCARD_SEGMENT}-bearing
@@ -11231,10 +11793,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
@@ -11311,25 +11911,12 @@ 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 usesApplicantContactSchema = contractUsesApplicantContactSchema({
+        inputBody,
+        isSubmissionFlow,
+        browserFlowOnly: omitExecuteHttp,
+        payloadFieldNames,
+    });
     const isReservedByApplicantContactSchema = (name) => usesApplicantContactSchema && applicantContactFieldNames.has(name);
     // A missing inputBody, or one with no ApplicantContactSchema evidence,
     // means this is not a job-application submission flow. The former keeps
@@ -11339,7 +11926,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
@@ -11455,11 +12042,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 && omitExecuteHttp && isSubmissionFlow;
+        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},`);
         }
     }
@@ -11670,7 +12262,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
@@ -11690,6 +12287,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`
         : "";
@@ -11770,7 +12370,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
@@ -12158,6 +12760,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
@@ -12175,9 +12790,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};
@@ -12207,14 +12822,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 };
@@ -12259,6 +12872,101 @@ 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));
+}
 /**
  * Escape a literal string segment so it is safe INSIDE a JS backtick template
  * literal — backslashes, backticks, and `${` interpolation starts must all be
@@ -12278,13 +12986,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
@@ -12351,6 +13063,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
@@ -12370,9 +13098,10 @@ 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;
+    const canonicalise = isSubmissionFlow && browserFlowOnly;
     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;
@@ -12399,7 +13128,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);
@@ -12424,7 +13153,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 }
@@ -12449,9 +13178,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,
@@ -12459,6 +13203,7 @@ function emitConfigManifest(opts) {
         spec: {
             defaultBaseUrl: baseUrl,
             ...(httpModulePath ? { httpModule: httpModulePath } : {}),
+            ...(multipart ? { multipart: true } : {}),
             request: { type: "object", properties: sortedRequestProperties },
             response: {
                 type: "object",
@@ -12493,7 +13238,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.
@@ -12507,7 +13252,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;
@@ -12534,7 +13279,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;
@@ -12557,10 +13302,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 = isSubmissionFlow && browserFlowOnly;
+    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 ||
+        contractUsesApplicantContactSchema({
+            inputBody,
+            isSubmissionFlow,
+            browserFlowOnly,
+            payloadFieldNames,
+        });
+    const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary ?? vocabulary_1.EMPTY_VOCABULARY, env, canonicalise);
     let usesThrowawayPassword = false;
     let usesEmailStep = false;
     const stepLiterals = flowSteps.map((step) => {
@@ -12602,14 +13359,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} },`;
@@ -12618,7 +13375,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
@@ -12633,7 +13392,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",
@@ -12689,8 +13448,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" : ""}
@@ -12747,7 +13506,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. */
@@ -13127,6 +13886,14 @@ async function main() {
             };
         }
     })();
+    const browserFlowOnlyOptIn = (() => {
+        try {
+            return parseBrowserFlowOnlyOptIn((0, node_fs_1.readFileSync)(flowFile, "utf8"));
+        }
+        catch {
+            return 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.
@@ -13163,7 +13930,9 @@ 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);
+        const baseUrl = activeCaptures.length === 0
+            ? "https://example.com"
+            : 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
@@ -13309,7 +14078,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);
@@ -13400,7 +14169,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
@@ -13502,7 +14276,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
@@ -13570,7 +14345,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({
@@ -13582,6 +14357,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.
@@ -13604,6 +14381,8 @@ async function main() {
             flowSteps,
             isSubmissionFlow,
             hasMultipartStep,
+            browserFlowOnly,
+            inputBody,
             vocabulary,
             frameSelector,
         });
@@ -13642,6 +14421,7 @@ async function main() {
             auxFiles,
             multiStepBody,
             omitExecuteHttp: browserFlowOnly,
+            createsAccount: browserFlow.usesThrowawayPassword,
             isSubmissionFlow,
             inputBody,
             hasMultipartStep,
@@ -13661,11 +14441,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,
@@ -13677,6 +14489,10 @@ 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