@enricai/barnacle 1.12.77 → 1.12.79

package/dist/scripts/recon-generate.js

@@ -62,13 +62,18 @@ exports.ancestorScopedAccessor = ancestorScopedAccessor;
 exports.compileActionSteps = compileActionSteps;
 exports.collectHeaderBindings = collectHeaderBindings;
 exports.deriveProducerBoundaryBindings = deriveProducerBoundaryBindings;
+exports.applyPayloadKeyValueSubstitutions = applyPayloadKeyValueSubstitutions;
 exports.collectUnboundLiterals = collectUnboundLiterals;
+exports.resolveRecurringNavigateToFacets = resolveRecurringNavigateToFacets;
 exports.emitMultiStepExecuteHttp = emitMultiStepExecuteHttp;
 exports.countSpliceableFacets = countSpliceableFacets;
 exports.spliceFacetsIntoStringVariable = spliceFacetsIntoStringVariable;
 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;
@@ -76,6 +81,7 @@ exports.resetScanPrimaryCandidateGroupsCallCountForTest = resetScanPrimaryCandid
 exports.detectDrillDownFoldPlan = detectDrillDownFoldPlan;
 exports.parseFoldReturnSpec = parseFoldReturnSpec;
 exports.parseFallbackGateSpec = parseFallbackGateSpec;
+exports.readComparableBodyLeaf = readComparableBodyLeaf;
 exports.collectRequestValuesIncludingHeaders = collectRequestValuesIncludingHeaders;
 exports.getFoldPlanResolutionCallCountForTests = getFoldPlanResolutionCallCountForTests;
 exports.resetFoldPlanResolutionCallCountForTests = resetFoldPlanResolutionCallCountForTests;
@@ -382,14 +388,53 @@ function extractNavigateToHashFragmentValue(url, previousHash) {
     if (hashIndex === -1)
         return null;
     const hash = url.slice(hashIndex + 1);
-    if (previousHash && hash.length > previousHash.length && hash.startsWith(previousHash)) {
-        const suffix = hash.slice(previousHash.length);
-        const delta = /^[,/]/.test(suffix) ? suffix.slice(1) : suffix;
-        if (delta.length > 0)
-            return delta;
+    if (previousHash) {
+        // A growing hash can add more than one token per step (a "label/value"
+        // pair, or a "key=value" pair), at either end, joined by any hash
+        // separator. The facet's actual VALUE is the last token that is new
+        // relative to the previous hash, with any "key=" prefix removed.
+        const previousTokens = new Set(splitHashTokens(previousHash));
+        const added = splitHashTokens(hash).filter((token) => !previousTokens.has(token));
+        const delta = added[added.length - 1];
+        if (delta !== undefined)
+            return stripHashKeyPrefix(delta);
+    }
+    const tokens = splitHashTokens(hash);
+    return tokens.length > 0 ? stripHashKeyPrefix(tokens[tokens.length - 1]) : null;
+}
+/**
+ * Single walk over navigateTo+payloadField steps shared by
+ * {@link harvestPersonaBindings} and {@link extractNavigateToFacetOrder}, so
+ * both derive identical literals. The delta baseline is the most recent
+ * 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) {
+    const facets = [];
+    let baselineHash;
+    for (const step of flowSteps) {
+        if (typeof step === "string" || step.navigateTo === undefined)
+            continue;
+        const hashIndex = step.navigateTo.indexOf("#");
+        const currentHash = hashIndex === -1 ? undefined : step.navigateTo.slice(hashIndex + 1);
+        if (step.payloadField) {
+            facets.push({
+                value: extractNavigateToHashFragmentValue(step.navigateTo, baselineHash),
+                field: step.payloadField,
+                optional: step.optional === true,
+            });
+        }
+        if (currentHash !== undefined)
+            baselineHash = currentHash;
     }
-    const segments = hash.split("/").filter((s) => s.length > 0);
-    return segments.length > 0 ? segments[segments.length - 1] : null;
+    return facets;
+}
+function splitHashTokens(hash) {
+    return hash.split(/[,/;&]/).filter((token) => token.length > 0);
+}
+function stripHashKeyPrefix(token) {
+    const stripped = token.slice(token.indexOf("=") + 1);
+    return stripped.length > 0 ? stripped : token;
 }
 /**
  * Derives a payload field name from the field LABEL in a fill/enter/type
@@ -437,7 +482,11 @@ function deriveFillLabelField(instruction) {
 function harvestPersonaBindings(flowSteps, vocabulary, env) {
     const bindings = new Map();
     const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary, env);
-    let previousNavigateToHash;
+    for (const facet of walkNavigateToFacets(flowSteps)) {
+        if (facet.value !== null && !bindings.has(facet.value)) {
+            bindings.set(facet.value, `payload.${facet.field}`);
+        }
+    }
     for (const step of flowSteps) {
         const isObj = typeof step !== "string";
         const instruction = isObj ? step.step : step;
@@ -448,21 +497,8 @@ function harvestPersonaBindings(flowSteps, vocabulary, env) {
         // `.../#/jobs/category-widgets`), so the value to correlate against
         // downstream header/body templates is the URL's own hash-derived
         // fragment, not anything extractStepPersonaValue could find in `step.step`.
-        if (isObj && step.navigateTo !== undefined) {
-            const hashIndex = step.navigateTo.indexOf("#");
-            const currentHash = hashIndex === -1 ? undefined : step.navigateTo.slice(hashIndex + 1);
-            if (!step.payloadField) {
-                previousNavigateToHash = currentHash;
-                continue;
-            }
-            const value = extractNavigateToHashFragmentValue(step.navigateTo, previousNavigateToHash);
-            previousNavigateToHash = currentHash;
-            if (value === null)
-                continue;
-            if (!bindings.has(value))
-                bindings.set(value, `payload.${step.payloadField}`);
+        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
@@ -492,26 +528,18 @@ function harvestPersonaBindings(flowSteps, vocabulary, env) {
  * which DOES see the captures, re-derive the same (value, field) pairs and
  * try the causally-adjacent-action fallback (see `emitMultiStepExecuteHttp`)
  * for whichever ones the recurrence-anchored path left unbound.
+ *
+ * A step whose URL carries no hash literal still holds its slot (empty
+ * `value`) so positional correlation against captured transitions stays
+ * aligned with the declared facets; {@link resolveRecurringNavigateToFacets}
+ * drops the empty literal itself and keeps only a correlated value.
  */
 function extractNavigateToFacetOrder(flowSteps) {
-    const order = [];
-    let previousNavigateToHash;
-    for (const step of flowSteps) {
-        if (typeof step === "string" || step.navigateTo === undefined)
-            continue;
-        const hashIndex = step.navigateTo.indexOf("#");
-        const currentHash = hashIndex === -1 ? undefined : step.navigateTo.slice(hashIndex + 1);
-        if (!step.payloadField) {
-            previousNavigateToHash = currentHash;
-            continue;
-        }
-        const value = extractNavigateToHashFragmentValue(step.navigateTo, previousNavigateToHash);
-        previousNavigateToHash = currentHash;
-        if (value === null || value.length === 0)
-            continue;
-        order.push({ value, field: step.payloadField, optional: step.optional === true });
-    }
-    return order;
+    return walkNavigateToFacets(flowSteps).map((facet) => ({
+        value: facet.value ?? "",
+        field: facet.field,
+        optional: facet.optional,
+    }));
 }
 /**
  * Detects a flow step whose quoted VALUE is the space-joined concatenation of
@@ -2824,6 +2852,17 @@ function jsonBodyLeafValues(requestPostData) {
     }
     return values;
 }
+/** Parses a captured request body as JSON; null for an absent or non-JSON body (multipart raw bytes). */
+function parseJsonBodyOrNull(requestPostData) {
+    if (typeof requestPostData !== "string" || requestPostData.length === 0)
+        return null;
+    try {
+        return JSON.parse(requestPostData);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Same JSON body walk as {@link jsonBodyLeafValues}, but grouped by the JSON
  * key/array-index that carries each leaf value — the by-name correlation
@@ -4031,7 +4070,28 @@ function containsValueAtTokenBoundary(haystack, needle) {
         from = at + needle.length;
     }
 }
-function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, envelopePath, rootBody, payloadAccessorExcludePattern) {
+const structuredFieldSamples = new WeakMap();
+/**
+ * Single registration point for a structured (array/object) payload field, so
+ * the declared schema type is inferred from every captured body carrying the
+ * field rather than from whichever body or visiting order reached it first.
+ * Both the by-index accessor loop and the whole-field substitution pass go
+ * through here, so an indexed accessor can never coexist with a string schema.
+ */
+function registerStructuredPayloadField(outStructuredKeys, field, value) {
+    if (value === undefined || value === null)
+        return;
+    const samplesByField = structuredFieldSamples.get(outStructuredKeys) ?? new Map();
+    structuredFieldSamples.set(outStructuredKeys, samplesByField);
+    const samples = samplesByField.get(field) ?? [];
+    samplesByField.set(field, samples);
+    const serialized = JSON.stringify(value);
+    if (samples.some((sample) => JSON.stringify(sample) === serialized))
+        return;
+    samples.push(value);
+    outStructuredKeys.set(field, inferZodSchemaFromSamples(samples));
+}
+function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, envelopePath, rootBody, payloadAccessorExcludePattern, ownedArrayPathKeys) {
     let result = template;
     let cursor = searchFrom;
     // The body root's own entries are eligible too, whenever the located
@@ -4041,11 +4101,11 @@ function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope,
     // pagination/sort block) outranks the root as the "form envelope". Root
     // keys already present on the envelope are skipped so nothing is visited
     // (or registered) twice.
-    const envelopeEntries = Object.entries(envelope);
-    const rootEntries = envelopePath.length === 0
+    const envelopeEntries = Object.entries(envelope).map(([key, value]) => [key, value, [...envelopePath, key]]);
+    const rootEntries = (envelopePath.length === 0
         ? []
-        : Object.entries(rootBody).filter(([key]) => key !== envelopePath[0] && !(key in envelope));
-    for (const [key, value] of [...envelopeEntries, ...rootEntries]) {
+        : Object.entries(rootBody).filter(([key]) => key !== envelopePath[0] && !(key in envelope))).map(([key, value]) => [key, value, [key]]);
+    for (const [key, value, valuePath] of [...envelopeEntries, ...rootEntries]) {
         const isNonEmptyArray = Array.isArray(value) && value.length > 0;
         const isNestedObject = value !== null &&
             typeof value === "object" &&
@@ -4053,6 +4113,22 @@ function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope,
             Object.keys(value).length > 0;
         if (!isNonEmptyArray && !isNestedObject)
             continue;
+        // An array path the facet pass owns is rendered element by element at every
+        // call site, so it is neither a payload field of its own nor swallowable.
+        if (isNonEmptyArray && ownedArrayPathKeys.has(arrayPathKey(valuePath)))
+            continue;
+        // Schema registration and the wholesale text-swallow below are
+        // independent concerns: this field's inferred Zod shape is correct
+        // regardless of whether any of the exclusion/guard checks below skip
+        // freezing its literal into the template. Registering it here (before
+        // those checks, and before even locating the span) keeps the generated
+        // contract's declared type in sync with payloadAccessorForPath's
+        // array/object accessors even when the wholesale swallow is skipped.
+        registerStructuredPayloadField(outStructuredKeys, key, value);
+        // A call site whose array carries a facet was already rewritten by the
+        // facet pass (the span-text guard below leaves it intact); a site whose
+        // array carries none falls through to the same opaque `payload.<key>`
+        // passthrough every non-facet array gets, so the declared field is used.
         if (unconditionalExcludeValues.size > 0 ||
             restrictedExcludeSourceByValue.size > 0 ||
             payloadAccessorExcludePattern !== null) {
@@ -4162,9 +4238,6 @@ function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope,
         const replacement = `$${"{"}JSON.stringify(payload.${key})${"}"}`;
         result = result.slice(0, spanStart) + replacement + result.slice(spanEnd);
         cursor = Math.max(cursor, spanStart + replacement.length);
-        if (!outStructuredKeys.has(key)) {
-            outStructuredKeys.set(key, inferZodSchema(value));
-        }
     }
     return { result, nextSearchFrom: cursor };
 }
@@ -4174,7 +4247,7 @@ function applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope,
  * pass to it. Shared by the top-level-object and top-level-array branches of
  * {@link applyStructuredValuePayloadSubstitutions} below.
  */
-function applyStructuredValuePayloadSubstitutionsForObjectBody(template, objectBody, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, payloadAccessorExcludePattern) {
+function applyStructuredValuePayloadSubstitutionsForObjectBody(template, objectBody, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, payloadAccessorExcludePattern, ownedArrayPathKeys) {
     const envelopePath = locateFormEnvelopePath(objectBody);
     let envelope = objectBody;
     for (const seg of envelopePath) {
@@ -4185,7 +4258,7 @@ function applyStructuredValuePayloadSubstitutionsForObjectBody(template, objectB
     if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) {
         return { result: template, nextSearchFrom: searchFrom };
     }
-    return applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, envelopePath, objectBody, payloadAccessorExcludePattern);
+    return applyStructuredValuePayloadSubstitutionsForEnvelope(template, envelope, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, searchFrom, envelopePath, objectBody, payloadAccessorExcludePattern, ownedArrayPathKeys);
 }
 /**
  * `priorStepStateBindings` carries the SAME value→binding map
@@ -4210,7 +4283,7 @@ function applyStructuredValuePayloadSubstitutionsForObjectBody(template, objectB
  * excluded from threading — the same value-coincidence class of bug
  * {@link keyNamesCorrelate}'s other call sites already guard against.
  */
-function applyStructuredValuePayloadSubstitutions(template, parsedBody, outStructuredKeys, priorStepStateBindings = new Map(), joinFieldValues = new Set(), payloadAccessorExcludeValues = new Map()) {
+function applyStructuredValuePayloadSubstitutions(template, parsedBody, outStructuredKeys, priorStepStateBindings = new Map(), joinFieldValues = new Set(), payloadAccessorExcludeValues = new Map(), ownedArrayPathKeys = new Set()) {
     if (parsedBody === null || typeof parsedBody !== "object") {
         return template;
     }
@@ -4237,13 +4310,13 @@ function applyStructuredValuePayloadSubstitutions(template, parsedBody, outStruc
         for (const element of parsedBody) {
             if (element === null || typeof element !== "object" || Array.isArray(element))
                 continue;
-            const { result: nextResult, nextSearchFrom } = applyStructuredValuePayloadSubstitutionsForObjectBody(result, element, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, cursor, payloadAccessorExcludePattern);
+            const { result: nextResult, nextSearchFrom } = applyStructuredValuePayloadSubstitutionsForObjectBody(result, element, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, cursor, payloadAccessorExcludePattern, ownedArrayPathKeys);
             result = nextResult;
             cursor = nextSearchFrom;
         }
         return result;
     }
-    const { result } = applyStructuredValuePayloadSubstitutionsForObjectBody(template, parsedBody, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, 0, payloadAccessorExcludePattern);
+    const { result } = applyStructuredValuePayloadSubstitutionsForObjectBody(template, parsedBody, outStructuredKeys, unconditionalExcludeValues, restrictedExcludeSourceByValue, 0, payloadAccessorExcludePattern, ownedArrayPathKeys);
     return result;
 }
 /** Maximum length to guard against indexing massive blobs (HTML fragments,
@@ -4508,12 +4581,22 @@ function payloadAccessorForPath(path) {
     const arrayIndexPos = path.findIndex((segment) => /^\d+$/.test(segment));
     if (arrayIndexPos === -1) {
         const field = pathToPayloadFieldName(path);
-        return { accessor: `payload.${field}`, field };
+        return { accessor: `payload.${field}`, field, structuredRootPath: null };
     }
     const objectPath = path.slice(0, arrayIndexPos);
     const field = objectPath.length > 0 ? pathToPayloadFieldName(objectPath) : (path[0] ?? "");
     const suffix = pathToAccessor(path.slice(arrayIndexPos), { assertNonNull: true });
-    return { accessor: `payload.${field}${suffix}`, field };
+    return {
+        accessor: `payload.${field}${suffix}`,
+        field,
+        structuredRootPath: objectPath.length > 0 ? objectPath : null,
+    };
+}
+/** Reads the value at `path` inside a parsed JSON body, or undefined when any hop is missing. */
+function valueAtJsonPath(root, path) {
+    return path.reduce((node, segment) => node !== null && typeof node === "object"
+        ? node[segment]
+        : undefined, root);
 }
 /** Derives a valid camelCase identifier from a fixture filename (e.g.
  * "10219132.json" -> "fixture10219132", "acme-metrics.config.json" ->
@@ -5686,12 +5769,29 @@ function applyPayloadKeyValueSubstitutions(template, inputBody, additionalBodies
 /** Every capture's response body from the same run, scanned only for
  * {@link CAPACITY_FIELD_NAME_PATTERN}-shaped numeric leaves — the
  * evidence source for a discovered "number" key's `capacityMax`. */
-responseBodiesForCapacitySignal = []) {
+responseBodiesForCapacitySignal = [], outStructuredKeys = new Map()) {
     const merged = [];
     const seenPairs = new Set();
     const seenValueByKey = new Map();
     const distinctValuesByKey = new Map();
     const allBodies = [inputBody, ...additionalBodies];
+    // Structure is registered from every body before any scalar is considered, so
+    // a name that is an array/object in one body and a primitive in another gets
+    // the structured schema regardless of which body is visited first.
+    for (const body of allBodies) {
+        if (body === undefined || body === null || typeof body !== "object" || Array.isArray(body)) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(body)) {
+            if (!isValidJsIdentifier(key))
+                continue;
+            if (value === null || typeof value !== "object")
+                continue;
+            if (Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0)
+                continue;
+            registerStructuredPayloadField(outStructuredKeys, key, value);
+        }
+    }
     for (const body of allBodies) {
         if (body === undefined || body === null || typeof body !== "object" || Array.isArray(body)) {
             continue;
@@ -5702,6 +5802,8 @@ responseBodiesForCapacitySignal = []) {
             const key = path[0];
             if (!isValidJsIdentifier(key))
                 continue;
+            if (outStructuredKeys.has(key))
+                continue;
             if (value === null)
                 continue;
             // Dedupe identical (key, value) pairs only — a repeated occurrence of
@@ -5870,17 +5972,57 @@ responseBodiesForCapacitySignal = []) {
  * steps declared any field to correlate against) or when a leaf's value has
  * no `key:value` segment matching one of them.
  */
-/** Yields every array-valued leaf in `value` (at any object nesting depth) —
- * `{@link applyOptionalArrayFacetSplicePayloadSubstitutions}`'s raw-array
- * search surface. Does not recurse INTO an array's own elements (a facet
- * array is always a flat array of primitives in every observed recon shape),
- * matching {@link walkAllPrimitiveLeaves}'s depth-first walk of everything
- * else. */
+/**
+ * Binds a scalar navigateTo facet at every call site: each object-property
+ * string leaf, at any depth, whose whole value equals a declared facet literal
+ * becomes `${payload.<field>}`. Matching is per whole leaf, so the same
+ * literal flanked by alphanumerics inside an unrelated token is never touched
+ * and no global collision guard can drop the facet. An optional facet falls
+ * back to the captured literal when the caller omits it, never `undefined`.
+ */
+function applyScalarFacetSplicePayloadSubstitutions(template, inputBody, navigateToFacets) {
+    if (navigateToFacets.length === 0)
+        return template;
+    if (inputBody === null || typeof inputBody !== "object")
+        return template;
+    let result = template;
+    for (const { value, path } of walkAllPrimitiveLeaves(inputBody)) {
+        if (typeof value !== "string" && typeof value !== "number")
+            continue;
+        if (/^\d+$/.test(path[path.length - 1] ?? ""))
+            continue;
+        const facet = matchFacetRecurrence(String(value), navigateToFacets, {
+            allowDelimiterSuffix: false,
+        });
+        if (facet === undefined)
+            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}}"`;
+        for (const sep of [":", ": "]) {
+            if (typeof value === "number") {
+                const re = new RegExp(`${sep}${literal}(?![\\w.])`, "g");
+                result = result.replace(re, () => `${sep}${replacement}`);
+                continue;
+            }
+            result = result.split(`${sep}${literal}`).join(`${sep}${replacement}`);
+        }
+    }
+    return result;
+}
+/** Yields every array in `value` (outermost first, at any nesting depth,
+ * including arrays inside array elements) — `{@link
+ * applyArrayFacetSplicePayloadSubstitutions}`'s raw-array search surface. */
 function* walkArrayLeaves(value, path = []) {
     if (value === null || typeof value !== "object")
         return;
     if (Array.isArray(value)) {
         yield { value, path };
+        for (const [index, inner] of value.entries()) {
+            yield* walkArrayLeaves(inner, [...path, String(index)]);
+        }
         return;
     }
     for (const [key, inner] of Object.entries(value)) {
@@ -5890,45 +6032,191 @@ function* walkArrayLeaves(value, path = []) {
 /**
  * REST-body counterpart to {@link spliceFacetsIntoArrayVariable}'s GraphQL
  * use: a navigateTo facet's literal recurring as one array element (suffixed
- * by a constant delimiter) inside a REST JSON body gets its element text
- * swapped for `${payload.<field>}` by the plain `interpolateStateValues`
- * splice later in the pipeline — but that pass only rewrites literal text
- * IN PLACE, so when the matched facet is optional it would leave the array's
- * frozen `undefined`-shaped element (and its JSON delimiter/comma) in the
- * output whenever the caller omits the field, instead of omitting the
- * element entirely.
+ * by a constant delimiter) inside a REST JSON body gets its element swapped
+ * for `${payload.<field>}` — for EVERY declared facet, required or optional,
+ * at EVERY call site's own array. Matching is structural (see
+ * {@link replaceJsonArrayOccurrences}) and token-boundary guarded per element
+ * ({@link matchArrayElementFacet}), so the splice never depends on the
+ * global, all-or-nothing persona collision guard, on which call site carried
+ * the array first, on element order, or on a facet being optional.
  *
- * This pass runs first and, for any array that matches at least one OPTIONAL
- * facet, rewrites the array's own frozen `JSON.stringify(...)` occurrence in
- * the body template to a single `${JSON.stringify([...])}` splice point
- * built from {@link spliceFacetsIntoArrayVariable}'s per-element conditional-
- * emission shape — the same `...(payload.<field> ? [...] : [])` convention
- * {@link spliceFacetsIntoStringVariable} already uses for the `key:value`
- * grammar. A required-only match (no optional facet in that array) is left
- * for the later plain splice to handle exactly as before — this pass is a
- * no-op whenever nothing it rewrites would differ, so the existing
- * required-only REST array-element shape (recon-generate-navigateto-array-
- * element-facet-splice-e2e.test.ts) never changes.
- */
-function applyOptionalArrayFacetSplicePayloadSubstitutions(template, inputBody, navigateToFacets) {
-    if (!navigateToFacets.some((facet) => facet.optional))
+ * Every facet-carrying array, whether its facets are required or optional, is
+ * rewritten to the same single `${JSON.stringify([...])}` splice point built
+ * from {@link spliceFacetsIntoArrayVariable}'s per-element conditional
+ * emission, so an absent optional facet drops its element instead of freezing
+ * an `undefined` and no call site renders the array through a different
+ * construction. Non-facet elements stay literal.
+ */
+function applyArrayFacetSplicePayloadSubstitutions(template, inputBody, navigateToFacets, ownedArrayPathKeys, siblingBodies = []) {
+    if (navigateToFacets.length === 0)
         return template;
     if (inputBody === null || typeof inputBody !== "object")
         return template;
     let result = template;
-    for (const { value } of walkArrayLeaves(inputBody)) {
-        const spliced = spliceFacetsIntoArrayVariable(value, navigateToFacets);
-        if (spliced === null || !spliced.includes("...(payload."))
+    for (const { value, path } of walkArrayLeaves(inputBody)) {
+        if (value.length === 0)
             continue;
-        const target = JSON.stringify(value);
-        if (!result.includes(target))
+        if (!ownedArrayPathKeys.has(arrayPathKey(path)) &&
+            !containsFacetArray(value, navigateToFacets)) {
             continue;
-        result = result.split(target).join(`\${JSON.stringify(${spliced})}`);
+        }
+        const absentFacets = collectSiblingArrayFacets(value, path, siblingBodies, navigateToFacets);
+        const absentFields = new Set(absentFacets.map(({ facet }) => facet.field));
+        const expression = renderFacetValueExpression([...value, ...absentFacets.map(({ element }) => element)], navigateToFacets.map((facet) => absentFields.has(facet.field) ? { ...facet, optional: true } : facet));
+        result = replaceJsonArrayOccurrences(result, value, `\${JSON.stringify(${expression})}`);
     }
     return result;
 }
-function applyFacetSplicePayloadSubstitutions(template, inputBody, payloadFieldNames, optionalFieldNames) {
-    if (payloadFieldNames.size === 0)
+/**
+ * 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 element of value) {
+                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 });
+            }
+        }
+    }
+    return absent;
+}
+/** Whether `value` is, or contains at any depth, an array with a
+ * facet-bearing string element. */
+function containsFacetArray(value, facets) {
+    for (const { value: array } of walkArrayLeaves(value)) {
+        const hasFacet = array.some((element) => typeof element === "string" && matchArrayElementFacet(element, facets));
+        if (hasFacet)
+            return true;
+    }
+    return false;
+}
+/** JS expression for `value` with every facet array at any depth spliced, so
+ * one construction covers arrays nested inside array elements. */
+function renderFacetValueExpression(value, facets) {
+    if (value === null || typeof value !== "object" || !containsFacetArray(value, facets)) {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return (spliceFacetsIntoArrayVariable(value, facets, (element) => renderFacetValueExpression(element, facets)) ?? `[${value.map((element) => renderFacetValueExpression(element, facets)).join(", ")}]`);
+    }
+    const entries = Object.entries(value).map(([key, inner]) => `${JSON.stringify(key)}: ${renderFacetValueExpression(inner, facets)}`);
+    return `{ ${entries.join(", ")} }`;
+}
+/** Full index-free path of an array: identifies the array across call sites
+ * whatever index it was captured at, without conflating same-named fields
+ * that live at different paths. */
+function arrayPathKey(path) {
+    return JSON.stringify(path.filter((segment) => !/^\d+$/.test(segment)));
+}
+/** True when `path` addresses anything inside an array in `ownedKeys`, at any
+ * depth (string or object element alike). */
+function isInsideOwnedArray(path, ownedKeys) {
+    return path.some((segment, index) => /^\d+$/.test(segment) && ownedKeys.has(arrayPathKey(path.slice(0, index))));
+}
+/**
+ * Path keys ({@link arrayPathKey}) of every array, in ANY captured body,
+ * that carries at least one facet-bearing element. The facet pass owns those
+ * arrays wholesale, so none of their elements may also be frozen as a
+ * by-index `payload.<field>["N"]` accessor, whichever body was parsed first
+ * and wherever the array sits in it.
+ */
+function collectFacetArrayPathKeys(bodies, facets) {
+    const keys = new Set();
+    if (facets.length === 0)
+        return keys;
+    for (const body of bodies) {
+        if (body === null || typeof body !== "object")
+            continue;
+        for (const { value, path } of walkArrayLeaves(body)) {
+            const hasFacet = value.some((element) => typeof element === "string" && matchArrayElementFacet(element, facets) !== undefined);
+            if (hasFacet)
+                keys.add(arrayPathKey(path));
+        }
+    }
+    return keys;
+}
+/**
+ * Rewrites every occurrence of `target` inside `template` by JSON structure
+ * (bracket-balanced, string-aware, whitespace-insensitive) rather than by
+ * exact `JSON.stringify` text, so a pretty-printed or re-spaced body array
+ * is still replaced.
+ */
+function replaceJsonArrayOccurrences(template, target, replacement) {
+    const targetKey = JSON.stringify(target);
+    let out = "";
+    let from = 0;
+    while (from < template.length) {
+        const open = template.indexOf("[", from);
+        if (open === -1)
+            break;
+        const close = findMatchingBracket(template, open);
+        const candidate = close === -1 ? undefined : template.slice(open, close + 1);
+        const matches = candidate !== undefined && jsonTextEquals(candidate, targetKey);
+        if (!matches) {
+            out += template.slice(from, open + 1);
+            from = open + 1;
+            continue;
+        }
+        out += template.slice(from, open) + replacement;
+        from = close + 1;
+    }
+    return out + template.slice(from);
+}
+function findMatchingBracket(text, open) {
+    let depth = 0;
+    let inString = false;
+    for (let i = open; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === "\\")
+                i++;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "[")
+            depth++;
+        else if (ch === "]" && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+function jsonTextEquals(candidate, targetKey) {
+    try {
+        return JSON.stringify(JSON.parse(candidate)) === targetKey;
+    }
+    catch {
+        return false;
+    }
+}
+/** A facet literal recurring inside a packed string under a key that does not
+ * name its payload field. A leaf that IS the bare literal is left to the scalar
+ * pass, which owns the optional fallback for it. */
+function packedFacetRecurrence(value, facets) {
+    const spliced = spliceFacetRecurrenceIntoScalarVariable(value, facets);
+    return spliced !== null && !spliced.startsWith("payload.") ? spliced : null;
+}
+function applyFacetSplicePayloadSubstitutions(template, inputBody, payloadFieldNames, optionalFieldNames, navigateToFacets = []) {
+    if (payloadFieldNames.size === 0 && navigateToFacets.length === 0)
         return template;
     if (inputBody === undefined ||
         inputBody === null ||
@@ -5939,18 +6227,23 @@ function applyFacetSplicePayloadSubstitutions(template, inputBody, payloadFieldN
     const fields = [...payloadFieldNames];
     let result = template;
     for (const { value, path } of walkAllPrimitiveLeaves(inputBody)) {
-        if (path.length !== 1)
-            continue;
-        const key = path[0];
-        if (!isValidJsIdentifier(key))
+        const key = path[path.length - 1];
+        if (key === undefined || !isValidJsIdentifier(key))
             continue;
         if (typeof value !== "string")
             continue;
-        const spliced = spliceFacetsIntoStringVariable(value, fields, optionalFieldNames);
+        const kv = spliceFacetsIntoStringVariable(value, fields, optionalFieldNames);
+        const spliced = kv ?? packedFacetRecurrence(value, navigateToFacets);
         if (spliced === null)
             continue;
         const target = `"${key}":${JSON.stringify(value)}`;
-        const replacement = `"${key}":"\${${spliced}}"`;
+        // A required-only packed value with nothing JSON-escaped splices in place,
+        // so the accessor sits directly in the string instead of nesting a template.
+        const inline = kv === null &&
+            spliced.startsWith("`") &&
+            !spliced.startsWith("`${") &&
+            JSON.stringify(value).slice(1, -1) === value;
+        const replacement = inline ? `"${key}":"${spliced.slice(1, -1)}"` : `"${key}":"\${${spliced}}"`;
         result = result.split(target).join(replacement);
     }
     return result;
@@ -6231,8 +6524,12 @@ function parseBodyLeafValues(requestPostData) {
  * affect (the already-working recurrence-anchored path exists precisely
  * because a real facet DOES recur in a later request; nothing here changes
  * that — this only supplies values for facets that are not found at all).
+ *
+ * Values that carry a literal of an already-reachable facet are explained by
+ * that facet and never enter the pool, so reachable facets' own transitions
+ * cannot skew the pool size away from the count of facets awaiting a value.
  */
-function collectNewlyAppearingRequestValueTransitions(actions) {
+function collectNewlyAppearingRequestValueTransitions(actions, explainedLiterals = []) {
     const seenGlobally = new Set();
     const transitions = [];
     for (let i = 1; i < actions.length; i++) {
@@ -6243,6 +6540,8 @@ function collectNewlyAppearingRequestValueTransitions(actions) {
         const record = (value) => {
             if (value.length === 0 || seenGlobally.has(value) || seenThisTransition.has(value))
                 return;
+            if (explainedLiterals.some((literal) => occursAtTokenBoundary(value, literal)))
+                return;
             seenThisTransition.add(value);
             values.push(value);
         };
@@ -6263,6 +6562,79 @@ function collectNewlyAppearingRequestValueTransitions(actions) {
     }
     return transitions;
 }
+/**
+ * Whether `value` occurs in every request body only at token boundaries (never
+ * flanked by an alphanumeric), so a global rewrite of it cannot mangle a longer
+ * token. Shared by the persona-binding guard and facet identity resolution.
+ */
+function bindsWithoutCollisionIn(bodies, value) {
+    const isAlnum = (ch) => ch !== undefined && /[A-Za-z0-9]/.test(ch);
+    for (const body of bodies) {
+        let from = 0;
+        while (true) {
+            const at = body.indexOf(value, from);
+            if (at === -1)
+                break;
+            if (isAlnum(body[at - 1]) || isAlnum(body[at + value.length]))
+                return false;
+            from = at + value.length;
+        }
+    }
+    return true;
+}
+/**
+ * Whether `value` occurs in `text` at least once flanked by non-alphanumerics,
+ * 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)
+        return false;
+    const isAlnum = (ch) => ch !== undefined && /[A-Za-z0-9]/.test(ch);
+    let from = 0;
+    while (true) {
+        const at = text.indexOf(value, from);
+        if (at === -1)
+            return false;
+        if (!isAlnum(text[at - 1]) && !isAlnum(text[at + value.length]))
+            return true;
+        from = at + 1;
+    }
+}
+/**
+ * Every literal the flow's declared navigateTo facets take in the captured
+ * traffic: the hash-derived literal plus, for a facet whose hash literal never
+ * recurs, the body/query value {@link correlateUnreachableNavigateToFacets}
+ * pairs it with. Every per-site splice pass matches against this one list, so
+ * a facet is judged to recur identically by all of them instead of each pass
+ * deciding from the hash-derived literal alone.
+ */
+function resolveRecurringNavigateToFacets(declared, actions) {
+    const appearsAnywhere = (value) => actions.some(({ capture }) => occursAtTokenBoundary(capture.url, value) ||
+        (capture.requestPostData != null &&
+            occursAtTokenBoundary(capture.requestPostData, value)) ||
+        Object.values(capture.requestHeaders).some((h) => occursAtTokenBoundary(h, value)));
+    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)
+        return resolvedDeclared;
+    const correlated = correlateUnreachableNavigateToFacets(unreachable, actions, reachable.map(({ value }) => value));
+    if (correlated === null)
+        return resolvedDeclared;
+    const bodies = actions
+        .map(({ capture }) => capture.requestPostData)
+        .filter((body) => typeof body === "string" && body.length > 0);
+    const extras = unreachable.flatMap((facet) => {
+        const diffed = correlated.get(facet.field);
+        if (diffed === undefined || diffed.length === 0)
+            return [];
+        if (declared.some(({ value }) => value === diffed))
+            return [];
+        return bindsWithoutCollisionIn(bodies, diffed) ? [{ ...facet, value: diffed }] : [];
+    });
+    return [...resolvedDeclared, ...extras];
+}
 /**
  * Resolves each zero-recurrence navigateTo facet (in flow order) to the real
  * request value it causally affects, or returns `null` when the correlation
@@ -6279,14 +6651,27 @@ function collectNewlyAppearingRequestValueTransitions(actions) {
  * no longer guaranteed to line facets up with the RIGHT transition, so
  * nothing is bound — leaving a facet declared-but-unbound is preferable to
  * silently wiring it to another facet's (or an unrelated transition's) value.
+ *
+ * When the TOTAL transition count (ambiguous ones included) equals the facet
+ * count, each ambiguous transition still holds its facet's slot, so only that
+ * facet stays unbound while the others bind by position.
  */
-function correlateUnreachableNavigateToFacets(facets, actions) {
-    const unambiguousValues = collectNewlyAppearingRequestValueTransitions(actions)
+function correlateUnreachableNavigateToFacets(facets, actions, explainedLiterals) {
+    const transitions = collectNewlyAppearingRequestValueTransitions(actions, explainedLiterals);
+    const byField = new Map();
+    if (transitions.length === facets.length) {
+        facets.forEach(({ field }, index) => {
+            const transition = transitions[index];
+            if (transition.length === 1)
+                byField.set(field, transition[0]);
+        });
+        return byField.size > 0 ? byField : null;
+    }
+    const unambiguousValues = transitions
         .filter((transition) => transition.length === 1)
         .map((transition) => transition[0]);
     if (unambiguousValues.length !== facets.length)
         return null;
-    const byField = new Map();
     facets.forEach(({ field }, index) => {
         byField.set(field, unambiguousValues[index]);
     });
@@ -6333,12 +6718,30 @@ 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 navigateToFacetOrder = resolveRecurringNavigateToFacets(declaredNavigateToFacets, actions);
+    const facetArrayPathKeys = collectFacetArrayPathKeys(actions.map((action) => parseJsonBodyOrNull(action.capture.requestPostData)), navigateToFacetOrder);
     if (inputBody !== undefined && inputBody !== null) {
         for (const { value, path } of walkStringLeaves(inputBody)) {
             if (value.length < MIN_STATE_VALUE_LENGTH)
                 continue;
-            const { accessor, field: accessorField } = payloadAccessorForPath(path);
+            // An element of an array any call site's facet pass owns belongs to the
+            // facet's payloadField (or stays literal), not to a by-index accessor
+            // that would freeze the sibling elements' shape.
+            if (isInsideOwnedArray(path, facetArrayPathKeys))
+                continue;
+            // A leaf recurring as a declared facet literal binds to that facet's
+            // payloadField via the persona pass, not to a by-index accessor.
+            if (matchFacetRecurrence(value, navigateToFacetOrder, { allowDelimiterSuffix: true })) {
+                continue;
+            }
+            const { accessor, field: accessorField, structuredRootPath } = payloadAccessorForPath(path);
             payloadAccessorByValue.set(value, accessor);
+            // The accessor indexes into this field, so its declared type must be the
+            // structured shape regardless of whether Mechanism B visited the key.
+            if (structuredRootPath !== null) {
+                registerStructuredPayloadField(outStructuredKeys, accessorField, valueAtJsonPath(inputBody, structuredRootPath));
+            }
             if (isValidJsIdentifier(accessorField))
                 outDiscoveredFields.add(accessorField);
             // Phase F: register a lowercase variant for UUID-shaped values so case-
@@ -6428,31 +6831,22 @@ flowSteps = [], vocabulary = undefined) {
     // or when the correlation is ambiguous (see
     // `correlateUnreachableNavigateToFacets`), there is nothing safe to splice
     // and the field(s) stay unbound rather than risk a wrong binding.
-    const appearsAnywhereInCapture = (value) => actions.some((action) => action.capture.url.includes(value) ||
-        (action.capture.requestPostData?.includes(value) ?? false) ||
-        Object.values(action.capture.requestHeaders).some((h) => h.includes(value)));
-    // Hoisted once so both the unreachable-facet fallback above and the
-    // REST array-element optional splice below (applyOptionalArrayFacetSplice
-    // PayloadSubstitutions) share the exact same (value, field, optional)
-    // triples — the array splice must see each binding's `optional` flag
-    // precisely as the flow declared it, same as the already-fixed GraphQL
-    // array-variable path ({@link spliceFacetsIntoArrayVariable}).
-    const navigateToFacetOrder = extractNavigateToFacetOrder(flowSteps);
-    const unreachableNavigateToFacets = navigateToFacetOrder.filter(({ value }) => !appearsAnywhereInCapture(value));
-    if (unreachableNavigateToFacets.length > 0) {
-        const correlated = correlateUnreachableNavigateToFacets(unreachableNavigateToFacets, actions);
-        for (const { field } of correlated === null ? [] : unreachableNavigateToFacets) {
-            const diffed = correlated?.get(field);
-            if (diffed === undefined)
-                continue;
-            if (!bindsWithoutCollision(diffed))
-                continue;
-            if (payloadAccessorByValue.has(diffed))
-                continue;
-            payloadAccessorByValue.set(diffed, `payload.${field}`);
-            if (isValidJsIdentifier(field))
-                outDiscoveredFields.add(field);
+    // Every facet any splice pass binds comes from the one resolved list, so the
+    // schema declaration and accessor table cannot disagree with the splices.
+    const declaredFacetValues = new Set(declaredNavigateToFacets.map(({ value }) => value));
+    for (const { value, field } of navigateToFacetOrder) {
+        if (!isValidJsIdentifier(field))
+            continue;
+        if (declaredFacetValues.has(value)) {
+            outDiscoveredFields.add(field);
+            continue;
         }
+        if (!bindsWithoutCollision(value))
+            continue;
+        if (payloadAccessorByValue.has(value))
+            continue;
+        payloadAccessorByValue.set(value, `payload.${field}`);
+        outDiscoveredFields.add(field);
     }
     // Job coordinates from the recon entry URL's query string (e.g.
     // `?jobSeqNo=...`). Registered the same way as BaseUrl so every verbatim
@@ -6600,6 +6994,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) {
@@ -6705,7 +7114,7 @@ flowSteps = [], vocabulary = undefined) {
         // same declared field set, just applied to REST body text instead of a
         // variables object literal.
         const rawBodyWithFacetSplices = parsedBody !== null
-            ? applyFacetSplicePayloadSubstitutions(rawBodyWithFormSubs, parsedBody, restPayloadFieldNames, restOptionalFieldNames)
+            ? applyFacetSplicePayloadSubstitutions(rawBodyWithFormSubs, parsedBody, restPayloadFieldNames, restOptionalFieldNames, navigateToFacetOrder)
             : rawBodyWithFormSubs;
         // Optional-facet array-element splice — a navigateTo facet literal
         // recurring as one element of an array field (not the `key:value`
@@ -6713,10 +7122,13 @@ flowSteps = [], vocabulary = undefined) {
         // when its binding is optional and the caller omits it. Runs BEFORE
         // Mechanism B (below) can swallow the whole array wholesale as an
         // unparameterized structured value — see
-        // {@link applyOptionalArrayFacetSplicePayloadSubstitutions}.
+        // {@link applyArrayFacetSplicePayloadSubstitutions}.
         const rawBodyWithOptionalArrayFacetSplices = parsedBody !== null
-            ? applyOptionalArrayFacetSplicePayloadSubstitutions(rawBodyWithFacetSplices, parsedBody, navigateToFacetOrder)
+            ? applyArrayFacetSplicePayloadSubstitutions(rawBodyWithFacetSplices, parsedBody, navigateToFacetOrder, facetArrayPathKeys, absorbedSiblingBodiesByStep.get(i))
             : rawBodyWithFacetSplices;
+        const rawBodyWithScalarFacetSplices = parsedBody !== null
+            ? applyScalarFacetSplicePayloadSubstitutions(rawBodyWithOptionalArrayFacetSplices, parsedBody, navigateToFacetOrder)
+            : rawBodyWithOptionalArrayFacetSplices;
         // Mechanism B — parameterize whole nested caller structures
         // (experienceData/educationData history, opaque eventData) BEFORE value
         // substitution reaches inside them: swallowing the entire array/object first
@@ -6727,7 +7139,7 @@ flowSteps = [], vocabulary = undefined) {
         // dependent-drill-down join field (e.g. a bulk `{"tokens":[...]}` lookup)
         // must stay reachable for state threading, not get frozen as caller data.
         const rawBodyWithStructuredSubs = parsedBody !== null
-            ? applyStructuredValuePayloadSubstitutions(rawBodyWithOptionalArrayFacetSplices, parsedBody, outStructuredKeys, deriveStateVarByValue(prior, cap), joinFieldValuesByStep.get(i) ?? new Set(), payloadAccessorByValue)
+            ? applyStructuredValuePayloadSubstitutions(rawBodyWithScalarFacetSplices, parsedBody, outStructuredKeys, deriveStateVarByValue(prior, cap), joinFieldValuesByStep.get(i) ?? new Set(), payloadAccessorByValue, facetArrayPathKeys)
             : rawBodyWithFormSubs;
         // Whole-value caller coordinates bind here — after structured subs, BEFORE
         // state threading — so a composite coordinate (a jobLocation or jobSeqNo
@@ -6759,7 +7171,7 @@ flowSteps = [], vocabulary = undefined) {
             ? applyUrlParamPayloadSubstitutions(rawBodyWithProducerBoundary, parsedBody, urlParamBindings)
             : rawBodyWithProducerBoundary;
         const bodyAfterStateAndKv = rawBodyWithUrlParams
-            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues, joinFieldValuesByStep.get(i) ?? new Set()), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies)
+            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues, joinFieldValuesByStep.get(i) ?? new Set()), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies, outStructuredKeys)
             : "";
         // Mechanism A — generic (plain-JSON, wire-key-anchored) dropdown label→code
         // rewrite. Runs AFTER interpolateStateValues + the payload-KV pass, not
@@ -7650,6 +8062,87 @@ function spliceFacetsIntoStringVariable(value, fields, optionalFields = new Set(
     }
     return `[${elements.join(", ")}].join("")`;
 }
+/**
+ * Token-boundary match of one array element against the declared navigateTo
+ * facets — the single place elements are matched so the GraphQL and REST
+ * paths (and the REST accessor registration) never disagree on what a
+ * facet-bearing element is.
+ */
+function matchArrayElementFacet(element, facets) {
+    return matchFacetRecurrence(element, facets, { allowDelimiterSuffix: true });
+}
+/**
+ * The one facet-recurrence predicate every grammar (array element, scalar
+ * leaf) consults, so a declared facet literal is judged to recur identically
+ * everywhere. A number leaf is compared by its string form, so a numeric body
+ * value matches the string literal a navigateTo hash yields. With
+ * `allowDelimiterSuffix`, a literal followed by a non-alphanumeric delimiter
+ * suffix also matches. The longest literal wins.
+ */
+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)
+            return best;
+        return best === undefined || literal.length > best.value.length ? facet : best;
+    }, undefined);
+}
+/**
+ * Binds a top-level GraphQL variable whose scalar value (or, for a string, any
+ * `key:value` packed segment's value) recurs as a declared navigateTo facet
+ * literal, via the shared {@link matchFacetRecurrence} predicate so GraphQL
+ * judges recurrence exactly as the array and REST scalar passes do.
+ */
+function spliceFacetRecurrenceIntoScalarVariable(value, facets) {
+    if (facets.length === 0)
+        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 (typeof value !== "string")
+        return null;
+    const segments = value.split(/([|,;])/);
+    let bound = false;
+    let anyOptional = false;
+    const units = [];
+    for (let index = 0; index < segments.length; index += 2) {
+        const segment = segments[index];
+        const trailingDelimiter = segments[index + 1] ?? "";
+        const colonIndex = segment.indexOf(":");
+        const facet = colonIndex < 0
+            ? undefined
+            : matchFacetRecurrence(segment.slice(colonIndex + 1), facets, {
+                allowDelimiterSuffix: false,
+            });
+        if (facet === undefined) {
+            units.push(`\`${escapeForTemplateLiteral(segment + trailingDelimiter)}\``);
+            continue;
+        }
+        bound = true;
+        const unit = `\`${escapeForTemplateLiteral(segment.slice(0, colonIndex + 1))}\${payload.${facet.field}}${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) {
+            anyOptional = true;
+            units.push(`...(payload.${facet.field} ? [${unit}] : [])`);
+            continue;
+        }
+        units.push(unit);
+    }
+    if (!bound)
+        return null;
+    if (anyOptional)
+        return `[${units.join(", ")}].join("")`;
+    return `\`${units.map((unit) => unit.slice(1, -1)).join("")}\``;
+}
 /**
  * Splices a captured array-valued GraphQL variable's elements against
  * navigateTo facet bindings instead of the `key:value` segment grammar
@@ -7665,24 +8158,16 @@ function spliceFacetsIntoStringVariable(value, fields, optionalFields = new Set(
  * {@link spliceFacetsIntoStringVariable} uses, so an absent optional facet
  * drops its element rather than emitting `undefined`.
  */
-function spliceFacetsIntoArrayVariable(value, facets) {
+function spliceFacetsIntoArrayVariable(value, facets, renderElement = (element) => JSON.stringify(element)) {
     if (!Array.isArray(value))
         return null;
-    const isAlnum = (ch) => ch !== undefined && /[A-Za-z0-9]/.test(ch);
-    const matchFacet = (element) => facets.find(({ value: literal }) => {
-        if (element === literal)
-            return true;
-        if (!element.startsWith(literal))
-            return false;
-        return !isAlnum(element[literal.length]);
-    });
     let matchCount = 0;
     const elements = value.map((element) => {
         if (typeof element !== "string")
-            return JSON.stringify(element);
-        const matched = matchFacet(element);
+            return renderElement(element);
+        const matched = matchArrayElementFacet(element, facets);
         if (!matched)
-            return JSON.stringify(element);
+            return renderElement(element);
         matchCount++;
         const suffix = element.slice(matched.value.length);
         const elementLiteral = `\`\${payload.${matched.field}}${escapeForTemplateLiteral(suffix)}\``;
@@ -7714,18 +8199,26 @@ function renderGqlVariablesExpr(variables, payloadFieldNames, optionalFieldNames
     if (variables === null || typeof variables !== "object" || Array.isArray(variables))
         return "{}";
     const fields = payloadFieldNames ? [...payloadFieldNames] : [];
-    const entries = Object.entries(variables).map(([key, value]) => {
-        const matchedField = fields.find((field) => field.toLowerCase() === key.toLowerCase());
-        const facetSpliceExpr = matchedField
-            ? null
-            : (spliceFacetsIntoStringVariable(value, fields, optionalFieldNames) ??
-                spliceFacetsIntoArrayVariable(value, navigateToFacets));
-        const valueExpr = matchedField
-            ? `payload.${matchedField}`
-            : (facetSpliceExpr ?? JSON.stringify(value));
-        return `${key}: ${valueExpr}`;
-    });
-    return entries.length > 0 ? `{ ${entries.join(", ")} }` : "{}";
+    const renderValue = (value) => {
+        const spliced = spliceFacetsIntoStringVariable(value, fields, optionalFieldNames) ??
+            spliceFacetsIntoArrayVariable(value, navigateToFacets, renderValue) ??
+            spliceFacetRecurrenceIntoScalarVariable(value, navigateToFacets);
+        if (spliced !== null)
+            return spliced;
+        if (Array.isArray(value))
+            return `[${value.map(renderValue).join(", ")}]`;
+        if (value !== null && typeof value === "object")
+            return renderObject(value);
+        return JSON.stringify(value);
+    };
+    const renderObject = (obj) => {
+        const entries = Object.entries(obj).map(([key, value]) => {
+            const matchedField = fields.find((field) => field.toLowerCase() === key.toLowerCase());
+            return `${isValidJsIdentifier(key) ? key : JSON.stringify(key)}: ${matchedField ? `payload.${matchedField}` : renderValue(value)}`;
+        });
+        return entries.length > 0 ? `{ ${entries.join(", ")} }` : "{}";
+    };
+    return renderObject(variables);
 }
 /** A count-style page-size key (e.g. `count`, `limit`, `first`) paired with a
  * skip-style offset key (e.g. `skip`, `offset`) in the same object is the
@@ -8063,7 +8556,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 {
@@ -8114,10 +8607,10 @@ function isExplainedByCorrelatedSiblingField(path, parsedBody, otherBodies, sibl
         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);
+            const siblingRaw = readComparableBodyLeaf(parsedBody, body, pathSegments);
             if (siblingRaw === undefined) {
                 // This body has a value for the field we're trying to explain but no
                 // value for the candidate sibling — the sibling can't vouch for it,
@@ -8228,7 +8721,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)))) {
@@ -9206,6 +9699,64 @@ 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];
+}
+/**
+ * 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`. 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;
+    return counterparts.find((candidate) => arrayElementIdentity(candidate) === identity);
+}
 /**
  * Turns a flow author's plain dot-separated {@link FoldReturnSpec.resultsPath}
  * / `drillResultsPath` into the SAME {@link ARRAY_WILDCARD_SEGMENT}-bearing
@@ -10730,6 +11281,64 @@ function buildContractChecklist(opts) {
         outOfTreeChecklistLine,
     ].filter((line) => line !== "");
 }
+const PAYLOAD_ACCESSOR_CHAIN = /\bpayload\.([A-Za-z_$][A-Za-z0-9_$]*)((?:!|\??\.[A-Za-z_$][A-Za-z0-9_$]*(?![A-Za-z0-9_$(])|\[(?:"[^"\]]*"|\d+)\])*)/g;
+const PAYLOAD_CHAIN_SEGMENT = /\??\.([A-Za-z_$][A-Za-z0-9_$]*)|\[(?:"[^"\]]*"|\d+)\]/g;
+function newAccessorShape() {
+    return { isArray: false, element: null, keys: new Map() };
+}
+function renderAccessorShape(shape) {
+    if (shape.isArray) {
+        return `z.array(${shape.element ? renderAccessorShape(shape.element) : "z.string()"})`;
+    }
+    if (shape.keys.size === 0)
+        return "z.string()";
+    const entries = [...shape.keys.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, child]) => `${isValidJsIdentifier(key) ? key : JSON.stringify(key)}: ${renderAccessorShape(child)}`);
+    return `z.object({ ${entries.join(", ")} })`;
+}
+/**
+ * Derives each `payload.<field>` Zod type from the full accessor chain the
+ * emitted body text uses (`payload.f["0"]!.x` => array of objects with key
+ * `x`), so the schema can never reject a property access the body performs.
+ */
+function deriveBodyAccessorShapes(body) {
+    const roots = new Map();
+    for (const m of body.matchAll(PAYLOAD_ACCESSOR_CHAIN)) {
+        const root = roots.get(m[1]) ?? newAccessorShape();
+        roots.set(m[1], root);
+        let node = root;
+        for (const seg of m[2].matchAll(PAYLOAD_CHAIN_SEGMENT)) {
+            if (seg[1] === undefined) {
+                node.isArray = true;
+                node.element ??= newAccessorShape();
+                node = node.element;
+                continue;
+            }
+            const child = node.keys.get(seg[1]) ?? newAccessorShape();
+            node.keys.set(seg[1], child);
+            node = child;
+        }
+    }
+    return roots;
+}
+function isStructuredAccessorShape(shape) {
+    return shape.isArray || shape.keys.size > 0;
+}
+/**
+ * Whether a declared Zod expression already admits every access the shape
+ * demands (array-ness and each dereferenced key), so a richer structured
+ * declaration is kept instead of being narrowed to the accessor-derived one.
+ */
+function declaredSchemaCoversAccessorShape(declared, shape) {
+    if (shape.isArray && !/\bz\.array\(/.test(declared))
+        return false;
+    if (!shape.isArray && shape.keys.size > 0 && !/\bz\.(object|record)\(/.test(declared)) {
+        return false;
+    }
+    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)));
+}
 /** 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) {
@@ -10891,7 +11500,10 @@ function emitContractTs(opts) {
     // override semantics a chain of `.extend()` calls used to have (each
     // subsequent `.extend` replaced an earlier field of the same name).
     const extendFields = new Map();
+    const structuredFieldNames = new Set();
     const addExtendField = (name, line) => {
+        if (structuredFieldNames.has(name))
+            return;
         extendFields.set(name, line);
     };
     // A detected bounded-paging signal means buildPaginatedFetchLoopExecuteHttpBody
@@ -11049,7 +11661,8 @@ function emitContractTs(opts) {
             continue;
         const key = isValidJsIdentifier(name) ? name : JSON.stringify(name);
         const value = payloadNeedsMultipart ? `multipartJsonObject(${schema})` : schema;
-        addExtendField(name, `  ${key}: ${value},`);
+        extendFields.set(name, `  ${key}: ${value},`);
+        structuredFieldNames.add(name);
     }
     // Closing-the-loop safety net: every discovered-field source above tracks
     // its own registration as it splices a `payload.<field>` accessor into the
@@ -11068,14 +11681,34 @@ function emitContractTs(opts) {
     // its structural root regardless of which upstream pass forgot to record a
     // field, instead of adding a fifth registration site that could itself be
     // forgotten by a future pass.
+    const accessorStructuredFields = new Set();
     if (multiStepBody) {
-        const bodyReferencedFields = new Set([...multiStepBody.matchAll(/\bpayload\.([A-Za-z_$][A-Za-z0-9_$]*)/g)].map((m) => m[1]));
-        for (const name of [...bodyReferencedFields].sort()) {
-            if (extendFields.has(name))
-                continue;
+        const bodyReferencedFields = deriveBodyAccessorShapes(multiStepBody);
+        for (const name of [...bodyReferencedFields.keys()].sort()) {
             if (isReservedByApplicantContactSchema(name))
                 continue;
-            addExtendField(name, `  ${name}: z.string(),`);
+            const shape = bodyReferencedFields.get(name);
+            const structured = isStructuredAccessorShape(shape);
+            // The body text is the ground truth for a field's shape: a scalar
+            // registration from any source must not outlive an accessor that indexes
+            // or dereferences the field, and a structured declaration is kept only
+            // when it already admits every access the body performs.
+            if (structured) {
+                const declared = extendFields.get(name);
+                if (structuredFieldNames.has(name) &&
+                    declared !== undefined &&
+                    declaredSchemaCoversAccessorShape(declared, shape)) {
+                    accessorStructuredFields.add(name);
+                    continue;
+                }
+                accessorStructuredFields.add(name);
+                structuredFieldNames.delete(name);
+            }
+            else if (extendFields.has(name)) {
+                continue;
+            }
+            const zod = renderAccessorShape(shape);
+            addExtendField(name, `  ${name}: ${zod === "z.string()" || !payloadNeedsMultipart ? zod : `multipartJsonObject(${zod})`},`);
         }
     }
     // The structural walk over the captured request body that used to BE the
@@ -11123,6 +11756,8 @@ function emitContractTs(opts) {
     // capture this run and is a no-op, not an error: there is no schema line
     // for it to attach to.
     for (const [fieldName, constraint] of Object.entries(valueConstraints)) {
+        if (accessorStructuredFields.has(fieldName))
+            continue;
         const line = extendFields.get(fieldName);
         if (line === null || line === undefined)
             continue;
@@ -11243,7 +11878,7 @@ 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 = extractNavigateToFacetOrder(contractFlowSteps);
+    const navigateToFacets = resolveRecurringNavigateToFacets(extractNavigateToFacetOrder(contractFlowSteps), actionSteps);
     const gqlVariablesExpr = gqlOperationName
         ? renderGqlVariablesExpr(gqlVariables, payloadFieldNames, optionalPayloadFieldNames, navigateToFacets)
         : paginationSignal