@enricai/barnacle 1.12.29 → 1.12.31

package/dist/scripts/recon-generate.js

@@ -2890,6 +2890,78 @@ function pathToFoldAccessorExpr(expr, path, depth = 0) {
     const outerExpr = `${expr}${pathToAccessor(before, { assertNonNull: false })}`;
     return `${outerExpr}.flatMap((${groupVar}) => ${pathToFoldAccessorExpr(groupVar, after, depth + 1)})`;
 }
+/**
+ * Emits nested `for` loops descending through every {@link
+ * ARRAY_WILDCARD_SEGMENT} in `path`, instead of {@link
+ * pathToFoldAccessorExpr}'s single `.flatMap` chain — a `.flatMap` callback
+ * only ever sees the group it flattens FROM, so the moment it returns the
+ * inner array, the outer (ancestor) object is gone from scope for the rest
+ * of the emitted fold body. A nested loop keeps every intermediate binding
+ * (`g0`, `g1`, ...) addressable inside the innermost loop, so a drill param
+ * that only lives on an ancestor object (e.g. a parent group id) can be read
+ * off that binding instead of being frozen as a literal. `varSuffix` mirrors
+ * the `itemVar`/`foldItemsVar` disambiguation suffix used when multiple fold
+ * plans share one function scope, so ancestor bindings from different plans
+ * can't collide either. Returns the loop's opening/closing lines (for the
+ * caller to splice its own loop-body lines between) plus the ordered
+ * (outer-to-inner) ancestor variable names — NOT including the innermost
+ * item, which the caller names itself via `itemVar`. Also splits the
+ * combined open/close into an ancestor-scope segment
+ * (`ancestorOpenLines`/`ancestorCloseLines`, empty when `path` crosses no
+ * wildcard) and an item-scope segment (`itemOpenLines`/`itemCloseLines`),
+ * so a caller whose per-target chain fetch never reads `itemVar` can splice
+ * that fetch between the two segments — once per ancestor tuple — instead
+ * of inside the item loop. `openLines`/`closeLines` remain the straight
+ * concatenation of the two segments, unchanged, for callers that don't need
+ * the split.
+ */
+function pathToFoldLoopLines(expr, path, itemVar, indent, varSuffix = "", depth = 0) {
+    const wildcardIndex = path.indexOf(ARRAY_WILDCARD_SEGMENT);
+    if (wildcardIndex === -1) {
+        const finalExpr = `${expr}${pathToAccessor(path, { assertNonNull: false })}`;
+        // At depth 0 with no wildcard crossing at all (the overwhelmingly common
+        // single-level fold), keep emitting the original `const foldItems = ...;`
+        // binding rather than inlining the accessor into the `for` — existing
+        // single-scope folds must emit byte-identical code, not merely
+        // equivalent code, since nothing about a flat fold needs the nested-loop
+        // rewrite in the first place.
+        const itemOpenLines = depth === 0
+            ? [
+                `${indent}const foldItems${varSuffix} = ${finalExpr};`,
+                `${indent}for (const ${itemVar} of foldItems${varSuffix}) {`,
+            ]
+            : [`${indent}for (const ${itemVar} of ${finalExpr}) {`];
+        const itemCloseLines = [`${indent}}`];
+        return {
+            openLines: itemOpenLines,
+            closeLines: itemCloseLines,
+            ancestorVars: [],
+            ancestorOpenLines: [],
+            itemOpenLines,
+            itemCloseLines,
+            ancestorCloseLines: [],
+        };
+    }
+    const before = path.slice(0, wildcardIndex);
+    const after = path.slice(wildcardIndex + 1);
+    const groupVar = `g${depth}${varSuffix}`;
+    const outerExpr = `${expr}${pathToAccessor(before, { assertNonNull: false })}`;
+    const inner = pathToFoldLoopLines(groupVar, after, itemVar, `${indent}  `, varSuffix, depth + 1);
+    const ancestorOpenLines = [
+        `${indent}for (const ${groupVar} of ${outerExpr}) {`,
+        ...inner.ancestorOpenLines,
+    ];
+    const ancestorCloseLines = [...inner.ancestorCloseLines, `${indent}}`];
+    return {
+        openLines: [...ancestorOpenLines, ...inner.itemOpenLines],
+        closeLines: [...inner.itemCloseLines, ...ancestorCloseLines],
+        ancestorVars: [groupVar, ...inner.ancestorVars],
+        ancestorOpenLines,
+        itemOpenLines: inner.itemOpenLines,
+        itemCloseLines: inner.itemCloseLines,
+        ancestorCloseLines,
+    };
+}
 /** Suggests a JS-camelCase variable name for a state value path. Falls back
  * up the path if the tail is numeric or not a valid JS identifier. */
 function pathToVarName(path) {
@@ -3692,29 +3764,40 @@ function emitFoldMatchAndMergeLines(terminalStep, target, itemVar, suffix, joinA
         ];
     }
     const foldMatchesExpr = pathToFoldAccessorExpr(`(${terminalStep.varName} as ${foldArrayAssertionType(target.chainArrayPath)})`, target.chainArrayPath);
+    const matchAccessorFor = (f, varName, optionalRoot) => {
+        const segments = f.split(".");
+        // The drill-down response is a DIFFERENT payload than the
+        // primary item, so it has no obligation to mirror the
+        // primary item's own nesting for the join key (e.g. a
+        // primary item's `identifiers.sku` is typically echoed
+        // back flat, as `sku`, on the drill response). Try the
+        // full nested path first (optional-chained, since an
+        // intermediate segment may not exist on a flat response),
+        // then fall back to the bare last segment.
+        const lastSegment = segments[segments.length - 1];
+        const bracket = (segment) => optionalRoot ? `?.[${JSON.stringify(segment)}]` : `[${JSON.stringify(segment)}]`;
+        const optionalBracketAccessor = segments
+            .map((segment) => `?.[${JSON.stringify(segment)}]`)
+            .join("");
+        return segments.length > 1
+            ? `(${varName}${optionalBracketAccessor} ?? ${varName}${bracket(lastSegment)})`
+            : `${varName}${bracket(lastSegment)}`;
+    };
+    const joinCondition = target.joinFields
+        .map((f) => `String(${matchAccessorFor(f, "m", false)}) === String(${joinAccessor(f)})`)
+        .join(" && ");
+    // A sole candidate whose join field(s) aren't present on it at all
+    // (common: many drill endpoints don't echo the request key back onto
+    // the response row) is trusted as-is — there's no sibling it could be
+    // confused with. But a sole candidate that DOES carry the join field
+    // with a different value is a genuine mismatch and must not be grafted
+    // on; two-or-more candidates always require an actual join-key match.
+    const soleCandidateFieldsAbsent = target.joinFields
+        .map((f) => `${matchAccessorFor(f, `foldMatches${suffix}[0]`, true)} === undefined`)
+        .join(" && ");
     return [
         `      const foldMatches${suffix} = ${foldMatchesExpr};`,
-        `      const foldMatch${suffix} = foldMatches${suffix}.find((m) => ${target.joinFields
-            .map((f) => {
-            const segments = f.split(".");
-            // The drill-down response is a DIFFERENT payload than the
-            // primary item, so it has no obligation to mirror the
-            // primary item's own nesting for the join key (e.g. a
-            // primary item's `identifiers.sku` is typically echoed
-            // back flat, as `sku`, on the drill response). Try the
-            // full nested path first (optional-chained, since an
-            // intermediate segment may not exist on a flat response),
-            // then fall back to the bare last segment.
-            const lastSegment = segments[segments.length - 1];
-            const optionalBracketAccessor = segments
-                .map((segment) => `?.[${JSON.stringify(segment)}]`)
-                .join("");
-            const matchAccessor = segments.length > 1
-                ? `(m${optionalBracketAccessor} ?? m[${JSON.stringify(lastSegment)}])`
-                : `m[${JSON.stringify(lastSegment)}]`;
-            return `String(${matchAccessor}) === String(${joinAccessor(f)})`;
-        })
-            .join(" && ")}) ?? foldMatches${suffix}[0];`,
+        `      const foldMatch${suffix} = foldMatches${suffix}.length === 1 && ${soleCandidateFieldsAbsent} ? foldMatches${suffix}[0] : foldMatches${suffix}.find((m) => ${joinCondition});`,
         `      Object.assign(${itemVar}, foldMatch${suffix} ?? {});`,
     ];
 }
@@ -4187,77 +4270,118 @@ function emitMultiStepExecuteHttp(actions, inputBody, errorSignals, fieldNameMap
             const primaryStep = actions[foldPlan.primaryStepIndex];
             // Read at the plan's OWN path rather than re-running the DFS: a
             // flow-declared `resultsPath` (see FoldReturnSpec) can name a different
-            // array than findObjectArrayField's first match.
-            const primaryItems = objectItemsAtPath(primaryStep.capture.responseBody, foldPlan.primaryArrayPath);
+            // array than findObjectArrayField's first match. Ancestor-aware so a
+            // drill param living only on a parent object (e.g. a group id) has a
+            // real object to be read off of, not just the flattened leaf item.
+            const primaryItemsWithAncestors = objectItemsWithAncestorsAtPath(primaryStep.capture.responseBody, foldPlan.primaryArrayPath);
             const primaryArrType = foldArrayAssertionType(foldPlan.primaryArrayPath);
             // Plan-level suffix mirrors the target-level suffix below: multiple
             // loop blocks now sharing the same function scope can't declare
-            // unsuffixed `foldItems`/`item` locals without colliding. The
+            // unsuffixed `item`/ancestor-binding locals without colliding. The
             // overwhelmingly common single-plan case keeps the original
             // unsuffixed names.
             const planSuffix = foldPlans.length > 1 ? String(matchingPlanIndex) : "";
-            const foldItemsVar = `foldItems${planSuffix}`;
-            const foldItemsExpr = pathToFoldAccessorExpr(`(${primaryStep.varName} as ${primaryArrType})`, foldPlan.primaryArrayPath);
             const itemVar = `item${planSuffix}`;
-            lines.push(`    const ${foldItemsVar} = ${foldItemsExpr};`, `    for (const ${itemVar} of ${foldItemsVar}) {`);
+            // Nested `for` loops (not a `.flatMap`-derived collection) so every
+            // intermediate array's binding stays addressable inside the innermost
+            // loop body — see pathToFoldLoopLines's docstring.
+            const { ancestorOpenLines, itemOpenLines, itemCloseLines, ancestorCloseLines, ancestorVars } = pathToFoldLoopLines(`(${primaryStep.varName} as ${primaryArrType})`, foldPlan.primaryArrayPath, itemVar, "    ", planSuffix);
+            lines.push(...ancestorOpenLines);
+            // Chain fetches for targets whose params + joinFields never reference
+            // itemVar are spliced here, above the item loop but inside the
+            // ancestor loop(s) — fetched once per ancestor tuple and reused by
+            // every descendant item's join/merge, instead of once per item.
+            const hoistedChainLines = [];
+            // Every target's join/merge — plus any non-hoistable target's own
+            // chain fetch — goes here, spliced inside the item loop.
+            const itemScopedLines = [];
             for (const [targetIndex, target] of foldPlan.targets.entries()) {
                 // `firstItem` decides which captured literal `parameterize` rewrites
                 // — it must be the item at `primaryMatchedItemIndex`, the one THIS
                 // target's drill request was actually built from, not always index
                 // 0, and can differ per target even though every target now shares
                 // the same runtime loop item.
-                const firstItem = primaryItems?.[target.primaryMatchedItemIndex];
-                if (!firstItem) {
+                const matchedPrimaryItem = primaryItemsWithAncestors[target.primaryMatchedItemIndex];
+                if (!matchedPrimaryItem) {
                     throw new Error(`emitMultiStepExecuteHttp: fold plan primary step ${primaryStep.varName} no longer resolves an object array at ${foldPlan.primaryArrayPath.join(".")} — the fold plan and this emitter have drifted out of sync`);
                 }
+                const { item: firstItem, ancestors: firstItemAncestors } = matchedPrimaryItem;
+                // Each ancestor binding (`g0`, `g1`, ...) paired with the design-time
+                // object it holds at runtime, so a threaded field resolved against
+                // that binding can be read off the same object `readValueAtPath`
+                // needs, and the runtime accessor built from the SAME variable name
+                // the emitted nested loop actually declares.
+                const ancestorObjByVar = new Map(ancestorVars.map((varName, idx) => [varName, firstItemAncestors[idx]]));
+                // Searched innermost-scope-first: the item's own field wins over an
+                // ancestor field of the same name.
+                const threadingScopes = [
+                    { varName: itemVar, obj: firstItem },
+                    ...ancestorVars.map((varName) => ({ varName, obj: ancestorObjByVar.get(varName) })),
+                ];
                 // Each target's chain variables and merge result get their own
                 // suffixed local names so multiple independent targets sharing the
                 // same loop body can each declare their own locals without
                 // colliding on `foldMatches`/`foldMatch`. The overwhelmingly common
                 // single-target case keeps the original unsuffixed names.
                 const suffix = foldPlan.targets.length > 1 ? `${planSuffix}${targetIndex}` : planSuffix;
-                const joinAccessor = (field) => `${itemVar}${pathToAccessor(field.split("."), { assertNonNull: false })}`;
-                // A join field can reach the render either as the raw captured literal
-                // (URL query params) or as an already-generic `${payload.<field>}`
-                // reference (top-level JSON body keys — see
-                // applyPayloadKeyValueSubstitutions, which payload-ifies every scalar
-                // body key regardless of length, running BEFORE this fold branch ever
-                // sees the value). Both must resolve to the loop item's own field, not
-                // a caller-supplied payload value shared across every iteration.
+                const scopedAccessor = (varName, field) => `${varName}${pathToAccessor(field.split("."), { assertNonNull: false })}`;
+                const joinAccessor = (field) => scopedAccessor(itemVar, field);
                 // Word-boundary anchored: a plain `.split(value).join(...)` would also
                 // rewrite unrelated substrings that happen to contain the join value
                 // (e.g. a "p1" product id colliding with a "/v1/" path segment or a
                 // "p10" sibling id), corrupting parts of the request the join field
                 // never touched.
                 const replaceWholeValue = (haystack, value, replacement) => haystack.replace(new RegExp(`\\b${value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g"), replacement);
-                const parameterize = (text) => target.joinFields.reduce((acc, field) => {
-                    const replacement = `\${${joinAccessor(field)}}`;
-                    // applyPayloadKeyValueSubstitutions only ever names a payload
-                    // accessor after the DRILL REQUEST's own top-level JSON key
-                    // (`${payload.sku}`), never after `field`'s dot path into the
-                    // PRIMARY ITEM — those are unrelated structures that only
-                    // happen to share a leaf name for a top-level join field. A
-                    // nested join field (e.g. `identifiers.sku`) must therefore
-                    // also match on its bare last segment, or the accessor swap
-                    // silently no-ops and leaves an undefined `payload.sku`
-                    // reference behind once the literal value itself has already
-                    // been replaced by the payload-key-value pass.
-                    const lastSegment = field.split(".").pop();
-                    const withAccessorSwapped = acc
-                        .split(`\${payload.${field}}`)
-                        .join(replacement)
-                        .split(`\${payload.${lastSegment}}`)
-                        .join(replacement);
-                    const value = readValueAtPath(firstItem, field.split("."));
-                    const stringValue = typeof value === "string" && value.length > 0
-                        ? value
-                        : typeof value === "number" || typeof value === "boolean"
-                            ? String(value)
-                            : null;
-                    return stringValue !== null
-                        ? replaceWholeValue(withAccessorSwapped, stringValue, replacement)
-                        : withAccessorSwapped;
-                }, text);
+                const parameterize = (text, chainCapture) => {
+                    // A join field can reach the render either as the raw captured
+                    // literal (URL query params) or as an already-generic
+                    // `${payload.<field>}` reference (top-level JSON body keys — see
+                    // applyPayloadKeyValueSubstitutions, which payload-ifies every
+                    // scalar body key regardless of length, running BEFORE this fold
+                    // branch ever sees the value). Both must resolve to the loop
+                    // item's (or ancestor's) own field, not a caller-supplied payload
+                    // value shared across every iteration. Widened beyond
+                    // `target.joinFields` to every field this specific chain hop's own
+                    // captured request actually varies on (via findThreadedJoinFields,
+                    // searched across the item AND every ancestor binding) — a param
+                    // living only on a parent object is otherwise structurally
+                    // invisible and gets frozen as a literal.
+                    const threadedFields = dedupeThreadedFields([
+                        ...target.joinFields.map((field) => ({ varName: itemVar, field })),
+                        ...findThreadedJoinFields(threadingScopes, chainCapture, actions.map((a) => a.capture)),
+                    ]);
+                    const result = threadedFields.reduce((acc, { varName, field }) => {
+                        const replacement = `\${${scopedAccessor(varName, field)}}`;
+                        // applyPayloadKeyValueSubstitutions only ever names a payload
+                        // accessor after the DRILL REQUEST's own top-level JSON key
+                        // (`${payload.sku}`), never after `field`'s dot path into the
+                        // PRIMARY ITEM — those are unrelated structures that only
+                        // happen to share a leaf name for a top-level join field. A
+                        // nested join field (e.g. `identifiers.sku`) must therefore
+                        // also match on its bare last segment, or the accessor swap
+                        // silently no-ops and leaves an undefined `payload.sku`
+                        // reference behind once the literal value itself has already
+                        // been replaced by the payload-key-value pass.
+                        const lastSegment = field.split(".").pop();
+                        const withAccessorSwapped = acc
+                            .split(`\${payload.${field}}`)
+                            .join(replacement)
+                            .split(`\${payload.${lastSegment}}`)
+                            .join(replacement);
+                        const scopeObj = varName === itemVar ? firstItem : ancestorObjByVar.get(varName);
+                        const value = readValueAtPath(scopeObj, field.split("."));
+                        const stringValue = typeof value === "string" && value.length > 0
+                            ? value
+                            : typeof value === "number" || typeof value === "boolean"
+                                ? String(value)
+                                : null;
+                        return stringValue !== null
+                            ? replaceWholeValue(withAccessorSwapped, stringValue, replacement)
+                            : withAccessorSwapped;
+                    }, text);
+                    assertNoFrozenVaryingDrillParams("emitMultiStepExecuteHttp", chainCapture, result, actions.map((a) => a.capture));
+                    return result;
+                };
                 // Every chain step's response and produces are block-scoped to this
                 // `for` — they never escape to the rest of the function. That is
                 // exactly the constraint the previous (now-removed) throw enforced by
@@ -4267,19 +4391,33 @@ function emitMultiStepExecuteHttp(actions, inputBody, errorSignals, fieldNameMap
                 // templates by the pass above, same as it would be for any two
                 // sequential non-fold steps) resolves them from this narrower scope.
                 const chainDeclared = new Set();
+                const chainLines = [];
+                // True once any chain step's parameterized url/headers/body actually
+                // ends up referencing `itemVar` — determined off the SAME
+                // `parameterize` substitutions the emitted call itself uses (not a
+                // fresh value scan), so this can never disagree with what the
+                // request literally interpolates. `ancestorVars.length === 0` means
+                // there is no ancestor loop to hoist into in the first place (a
+                // flat, single-level fold), so it is treated as item-scoped too —
+                // existing flat folds must keep emitting byte-identical code.
+                const itemVarRefPattern = new RegExp(`\\$\\{${itemVar}[.[]`);
+                let referencesItemVar = ancestorVars.length === 0;
                 for (const chainIndex of target.chain) {
                     const chainStep = actions[chainIndex];
                     const chainRendered = rendered[chainIndex];
-                    lines.push(`      const ${chainStep.varName} = (await httpClient(\`${parameterize(chainRendered.url)}\`, {`, `        method: ${JSON.stringify(chainRendered.method)},`);
-                    const joined = [
-                        parameterize(chainRendered.headersExpr),
-                        parameterize(chainRendered.bodyArg),
-                    ]
-                        .filter((s) => s !== "")
-                        .join(" ");
+                    const paramUrl = parameterize(chainRendered.url, chainStep.capture);
+                    const paramHeaders = parameterize(chainRendered.headersExpr, chainStep.capture);
+                    const paramBody = parameterize(chainRendered.bodyArg, chainStep.capture);
+                    if (itemVarRefPattern.test(paramUrl) ||
+                        itemVarRefPattern.test(paramHeaders) ||
+                        itemVarRefPattern.test(paramBody)) {
+                        referencesItemVar = true;
+                    }
+                    chainLines.push(`      const ${chainStep.varName} = (await httpClient(\`${paramUrl}\`, {`, `        method: ${JSON.stringify(chainRendered.method)},`);
+                    const joined = [paramHeaders, paramBody].filter((s) => s !== "").join(" ");
                     if (joined !== "")
-                        lines.push(`        ${joined}`);
-                    lines.push(`        schema: ${chainRendered.schemaExpr},`, `      })) as Record<string, unknown>;`);
+                        chainLines.push(`        ${joined}`);
+                    chainLines.push(`        schema: ${chainRendered.schemaExpr},`, `      })) as Record<string, unknown>;`);
                     for (const p of chainStep.produces) {
                         if (p.kind === "header")
                             continue;
@@ -4289,13 +4427,20 @@ function emitMultiStepExecuteHttp(actions, inputBody, errorSignals, fieldNameMap
                             continue;
                         chainDeclared.add(p.name);
                         const assertion = pathToAssertionType(p.path);
-                        lines.push(`      const ${p.name} = (${chainStep.varName} as ${assertion})${pathToAccessor(p.path, { assertNonNull: false })};`);
+                        chainLines.push(`      const ${p.name} = (${chainStep.varName} as ${assertion})${pathToAccessor(p.path, { assertNonNull: false })};`);
                     }
                 }
                 const terminalStep = actions[target.chainTerminalIndex];
-                lines.push(...emitFoldMatchAndMergeLines(terminalStep, target, itemVar, suffix, joinAccessor));
+                const matchLines = emitFoldMatchAndMergeLines(terminalStep, target, itemVar, suffix, joinAccessor);
+                if (referencesItemVar) {
+                    itemScopedLines.push(...chainLines, ...matchLines);
+                }
+                else {
+                    hoistedChainLines.push(...chainLines);
+                    itemScopedLines.push(...matchLines);
+                }
             }
-            lines.push(`    }`, "");
+            lines.push(...hoistedChainLines, ...itemOpenLines, ...itemScopedLines, ...itemCloseLines, ...ancestorCloseLines, "");
             continue;
         }
         // Every other chain step (already fully emitted, inline, by the fold
@@ -4714,21 +4859,53 @@ function findObjectArrayFieldOrWholeObject(value, path = []) {
  * path segment (e.g. `/orders/{id}`) rather than a query param or body
  * field. Numeric leaves are included because a join key is just as often a
  * numeric id (threaded as a query param string or a JSON body number
- * literal) as a string one. */
-function collectRequestStringValues(capture) {
+ * literal) as a string one.
+ *
+ * `allCaptures`, when passed, gates every query param and body leaf on
+ * whether its OWN value (by param key / body path, via {@link endpointKey}'s
+ * same-endpoint grouping — the same grouping {@link
+ * findFrozenVaryingDrillParams} uses) ever differs on some other capture of
+ * the same endpoint. A value that never varies (e.g. `adults=2`) is left
+ * out, so callers matching by pure value equality (e.g. {@link
+ * findThreadedJoinFields}) can't bind that constant onto an unrelated field
+ * that coincidentally holds the same literal (e.g. a zero-valued `children`
+ * param matching a discount amount that also happens to be `0` in one
+ * capture, then diverges to a fraction in another). Path segments are
+ * exempt from this gate and always pass through — {@link endpointKey}
+ * already fixes the pathname, so a path segment can never be observed to
+ * vary within a matched group, the same rationale {@link
+ * findFrozenVaryingDrillParams} documents for the same exclusion. When no
+ * other capture of this endpoint exists in `allCaptures`, variance can't be
+ * observed either way, so every value is kept (unfiltered, matching the
+ * behavior when `allCaptures` is omitted). */
+function collectRequestStringValues(capture, allCaptures) {
+    const sameEndpointCaptures = allCaptures
+        ? allCaptures.filter((c) => c !== capture && endpointKey(c.url) === endpointKey(capture.url))
+        : [];
+    const varies = (own, others) => !allCaptures || sameEndpointCaptures.length === 0
+        ? true
+        : others.some((other) => other !== undefined && other !== own);
     const values = new Set();
     try {
         const url = new URL(capture.url);
-        for (const v of url.searchParams.values())
-            values.add(v);
         for (const segment of url.pathname.split("/").filter(Boolean))
             values.add(segment);
+        for (const [paramKey, value] of url.searchParams.entries()) {
+            const otherValues = sameEndpointCaptures.map((c) => {
+                try {
+                    return new URL(c.url).searchParams.get(paramKey) ?? undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            });
+            if (varies(value, otherValues))
+                values.add(value);
+        }
     }
     catch {
         // Relative or malformed URL — no query params or path segments to contribute.
     }
-    for (const v of jsonBodyLeafValues(capture.requestPostData) ?? [])
-        values.add(v);
     const parsedBody = (() => {
         try {
             return typeof capture.requestPostData === "string" && capture.requestPostData.length > 0
@@ -4740,13 +4917,136 @@ function collectRequestStringValues(capture) {
         }
     })();
     if (parsedBody !== undefined) {
-        for (const { value } of walkAllPrimitiveLeaves(parsedBody)) {
-            if (typeof value === "number" || typeof value === "boolean")
-                values.add(String(value));
+        for (const { path, value } of walkAllPrimitiveLeaves(parsedBody)) {
+            if (value === null)
+                continue;
+            const stringValue = String(value);
+            const otherValues = sameEndpointCaptures.map((c) => {
+                try {
+                    const otherBody = typeof c.requestPostData === "string" && c.requestPostData.length > 0
+                        ? JSON.parse(c.requestPostData)
+                        : undefined;
+                    if (otherBody === undefined)
+                        return undefined;
+                    const otherValue = readValueAtPath(otherBody, path);
+                    return otherValue === undefined ? undefined : String(otherValue);
+                }
+                catch {
+                    return undefined;
+                }
+            });
+            if (varies(stringValue, otherValues))
+                values.add(stringValue);
         }
     }
     return values;
 }
+/**
+ * Finds every query param or JSON body leaf on `capture`'s own request that
+ * (a) was left as a literal in `renderedText` — never swapped for a
+ * `${...}` accessor by the threading pass above — and (b) took a different
+ * value on some OTHER capture matching the exact same endpoint (same
+ * origin+pathname, via {@link endpointKey}) anywhere in the run. Freezing
+ * such a value bakes ONE capture's drill parameter into every fold
+ * iteration's request, exactly the defect described in
+ * docs/recon-generate-nested-fold-flatmaps-away-the-parent-so-drill-params-freeze.md
+ * (a `packageCode`/`groupId`/`sailDate` triple that provably varies per
+ * cruise, silently frozen because no threaded field explained it). Path
+ * segments are deliberately not checked: {@link endpointKey} requires an
+ * identical pathname to group two captures at all, so no path segment can
+ * ever be observed to vary within a matched group.
+ */
+function findFrozenVaryingDrillParams(capture, renderedText, allCaptures) {
+    const key = endpointKey(capture.url);
+    const sameEndpointCaptures = allCaptures.filter((c) => c !== capture && endpointKey(c.url) === key);
+    if (sameEndpointCaptures.length === 0)
+        return [];
+    const isFrozenLiteral = (value) => value.length > 0 && renderedText.includes(value);
+    const frozen = [];
+    try {
+        const url = new URL(capture.url);
+        for (const [paramKey, value] of url.searchParams.entries()) {
+            if (!isFrozenLiteral(value))
+                continue;
+            const differing = sameEndpointCaptures
+                .map((c) => {
+                try {
+                    return new URL(c.url).searchParams.get(paramKey);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .find((v) => v !== null && v !== value);
+            if (differing !== undefined) {
+                frozen.push({
+                    location: "query parameter",
+                    key: paramKey,
+                    frozenValue: value,
+                    differingValue: differing,
+                });
+            }
+        }
+    }
+    catch {
+        // Relative or malformed URL — no query params to check.
+    }
+    const parsedBody = (() => {
+        try {
+            return typeof capture.requestPostData === "string" && capture.requestPostData.length > 0
+                ? JSON.parse(capture.requestPostData)
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    if (parsedBody !== undefined) {
+        for (const { path, value } of walkAllPrimitiveLeaves(parsedBody)) {
+            if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+                continue;
+            const stringValue = String(value);
+            if (!isFrozenLiteral(stringValue))
+                continue;
+            const fieldPath = path.join(".");
+            const differing = sameEndpointCaptures
+                .map((c) => {
+                try {
+                    const otherBody = typeof c.requestPostData === "string" && c.requestPostData.length > 0
+                        ? JSON.parse(c.requestPostData)
+                        : undefined;
+                    return otherBody === undefined ? undefined : readValueAtPath(otherBody, path);
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .find((v) => v !== undefined && String(v) !== stringValue);
+            if (differing !== undefined) {
+                frozen.push({
+                    location: "body field",
+                    key: fieldPath,
+                    frozenValue: stringValue,
+                    differingValue: String(differing),
+                });
+            }
+        }
+    }
+    return frozen;
+}
+/** Throws when {@link findFrozenVaryingDrillParams} finds any frozen-but-
+ * varying literal — shared by {@link parameterizeUrl} (below) and
+ * `emitMultiStepExecuteHttp`'s own `parameterize` so the two emitters can't
+ * drift on this guard. */
+function assertNoFrozenVaryingDrillParams(emitterName, capture, renderedText, allCaptures) {
+    const frozen = findFrozenVaryingDrillParams(capture, renderedText, allCaptures);
+    if (frozen.length === 0)
+        return;
+    const described = frozen
+        .map((f) => `${f.location} "${f.key}" (froze "${f.frozenValue}", also captured as "${f.differingValue}")`)
+        .join("; ");
+    throw new Error(`${emitterName}: drill request to ${endpointKey(capture.url)} would freeze a value that varied across this run's own captures: ${described} — no threaded field (item or ancestor) explains it, so baking in one capture's literal would silently reuse it for every fold iteration; add the missing field to joinFields or make it resolvable from an ancestor binding`);
+}
 /**
  * Yields every string/numeric/boolean leaf reachable from `item` by walking nested
  * plain objects only (not arrays — a join key is a scalar field of the item
@@ -4834,15 +5134,48 @@ function collectCandidateIndicesAscending(requestStringValueIndex, values, after
     }
     return [...candidates].sort((a, b) => a - b);
 }
-function findThreadedJoinFields(item, drillCapture) {
-    const requestValues = collectRequestStringValues(drillCapture);
+/** Drops duplicate `(varName, field)` pairs, keeping the first (innermost-
+ * scope-first, by {@link findThreadedJoinFields}'s scope ordering)
+ * occurrence — the same field can otherwise appear twice when both
+ * `target.joinFields` and the request-value scan resolve to it. */
+function dedupeThreadedFields(fields) {
+    const seen = new Set();
+    return fields.filter(({ varName, field }) => {
+        const key = `${varName}.${field}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Every per-item field, across `scopes`, whose value also appears somewhere
+ * in `drillCapture`'s own request (URL, body, headers) — the fields a drill
+ * request actually threads out of its per-item scope(s), used both to widen
+ * URL/body parameterization beyond a fold target's own `joinFields` and (via
+ * a single-scope call) to disambiguate which candidate array a chained step
+ * depends on. `scopes` is searched in the given order (innermost fold item
+ * first, then each ancestor binding a nested loop keeps addressable), since
+ * an ancestor field with the same name as an item field must not shadow the
+ * item's own value.
+ *
+ * `allCaptures`, when passed, is forwarded to {@link
+ * collectRequestStringValues} to gate matching on cross-capture variance:
+ * a param whose own value never varies across other captures of the same
+ * endpoint is excluded from the candidate set entirely, so a constant like
+ * `children=0` can't bind to an unrelated item field (a discount amount, a
+ * departure port) purely because both happen to equal the same literal at
+ * generation time. Omitted for the candidate-array disambiguation callers,
+ * where narrowing by variance is a different concern than the URL/body
+ * over-threading this gate exists to prevent. */
+function findThreadedJoinFields(scopes, drillCapture, allCaptures) {
+    const requestValues = collectRequestStringValues(drillCapture, allCaptures);
     if (requestValues.size === 0)
         return [];
-    return [...walkItemFieldPaths(item)]
+    return scopes.flatMap(({ varName, obj }) => [...walkItemFieldPaths(obj)]
         .filter(({ value: v }) => (typeof v === "string" && v.length > 0 && requestValues.has(v)) ||
         (typeof v === "number" && requestValues.has(String(v))) ||
         (typeof v === "boolean" && requestValues.has(String(v))))
-        .map(({ path }) => path.join("."));
+        .map(({ path }) => ({ varName, field: path.join(".") })));
 }
 /** Every string, numeric, and boolean leaf value present anywhere in a response —
  * the set a chained drill-down step's request must overlap with for that
@@ -4918,7 +5251,7 @@ function selectDisambiguatedCandidate(responseBody, capture) {
     if (candidates.length === 0)
         return null;
     const requestValues = collectRequestValuesIncludingHeaders(capture);
-    const threaded = candidates.find((candidate) => candidate.items.some((item) => findThreadedJoinFields(item, capture).length > 0));
+    const threaded = candidates.find((candidate) => candidate.items.some((item) => findThreadedJoinFields([{ varName: "item", obj: item }], capture).length > 0));
     if (threaded)
         return threaded;
     return candidates.reduce((richest, candidate) => {
@@ -5070,10 +5403,10 @@ function scanPrimaryCandidateGroups(actions, primaryIndex, globallyConsumedIndic
             // Every item in THIS candidate array is searched, not just items[0]
             // — a flow that only ever drilled into a later item (never the
             // first) must still resolve.
-            const primaryMatchedItemIndex = primaryArray.items.findIndex((item) => findThreadedJoinFields(item, drill.capture).length > 0);
+            const primaryMatchedItemIndex = primaryArray.items.findIndex((item) => findThreadedJoinFields([{ varName: "item", obj: item }], drill.capture).length > 0);
             if (primaryMatchedItemIndex === -1)
                 continue;
-            const joinFields = findThreadedJoinFields(primaryArray.items[primaryMatchedItemIndex], drill.capture);
+            const joinFields = findThreadedJoinFields([{ varName: "item", obj: primaryArray.items[primaryMatchedItemIndex] }], drill.capture).map((f) => f.field);
             // Widened to a flat (non-array) object response when the drill step has
             // no object-array field of its own — see
             // findAllObjectArrayFieldsOrWholeObject. A detail-by-id response (e.g.
@@ -5341,6 +5674,32 @@ function objectItemsAtPath(body, path) {
     const items = outer.flatMap((element) => objectItemsAtPath(element, after) ?? []);
     return items.length > 0 ? items : null;
 }
+/** Same flattening as {@link objectItemsAtPath}, but pairs each flattened
+ * leaf item with the ordered (outer-to-inner) chain of ancestor objects a
+ * `.flatMap` accessor would discard — one entry per {@link
+ * ARRAY_WILDCARD_SEGMENT} crossed on the way down. Index-aligned with
+ * {@link objectItemsAtPath}'s own output (same DFS/outer-array order), so a
+ * `FoldTarget.primaryMatchedItemIndex` resolves the same leaf item either
+ * way; this variant additionally exposes the ancestor objects a nested-loop
+ * emission ({@link pathToFoldLoopLines}) binds to `g0`/`g1`/... so drill
+ * threading can read a param off an ancestor scope, not only the item. */
+function objectItemsWithAncestorsAtPath(body, path, ancestors = []) {
+    const wildcardIndex = path.indexOf(ARRAY_WILDCARD_SEGMENT);
+    if (wildcardIndex === -1) {
+        const value = readValueAtPath(body, path);
+        if (Array.isArray(value)) {
+            return value.filter(isObjectArrayItem).map((item) => ({ item, ancestors: [...ancestors] }));
+        }
+        return isObjectArrayItem(value) ? [{ item: value, ancestors: [...ancestors] }] : [];
+    }
+    const outer = readValueAtPath(body, path.slice(0, wildcardIndex));
+    if (!Array.isArray(outer))
+        return [];
+    const after = path.slice(wildcardIndex + 1);
+    return outer.flatMap((element) => isObjectArrayItem(element)
+        ? objectItemsWithAncestorsAtPath(element, after, [...ancestors, element])
+        : []);
+}
 /**
  * Builds a {@link FoldPlan} from a flow-declared {@link FoldReturnSpec}, so a
  * site author can express a fold the structural heuristic misses.
@@ -6605,15 +6964,15 @@ const httpClient = createHttpClient({ schema: ${pascal}ResponseSchema, bottlenec
     const gqlVariablesExpr = gqlOperationName
         ? renderGqlVariablesExpr(gqlVariables, payloadFieldNames)
         : "{ q: payload.query }";
-    /** Builds the `for (const item of foldItems) { ... }` block(s) that fold
-     * every resolved plan's drill-down data onto `dataVarName`'s primary array
-     * — the single-primary counterpart of emitMultiStepExecuteHttp's own
-     * per-item loop, sharing its match/merge tail via
-     * {@link emitFoldMatchAndMergeLines} so the two can't describe different
-     * merge semantics. Chain hops beyond the drill step itself are rendered
-     * directly off each hop's own captured request (no state-threading
-     * pipeline) since a single-primary read flow carries no submitted payload
-     * for those calls to reference.
+    /** Builds the nested `for` loop block(s) — see {@link pathToFoldLoopLines}
+     * — that fold every resolved plan's drill-down data onto `dataVarName`'s
+     * primary array — the single-primary counterpart of
+     * emitMultiStepExecuteHttp's own per-item loop, sharing its match/merge
+     * tail via {@link emitFoldMatchAndMergeLines} so the two can't describe
+     * different merge semantics. Chain hops beyond the drill step itself are
+     * rendered directly off each hop's own captured request (no state-
+     * threading pipeline) since a single-primary read flow carries no
+     * submitted payload for those calls to reference.
      *
      * `itemsOverride`, when given, replaces the `dataVarName`+`primaryArrayPath`
      * accessor with a caller-supplied items expression — used by the paginated
@@ -6623,73 +6982,97 @@ const httpClient = createHttpClient({ schema: ${pascal}ResponseSchema, bottlenec
      * response object. `foldPlan.primaryArrayPath` may still declare depth
      * BELOW `itemsOverride.level` (a fold plan resolved against a nested array
      * inside each paginated item) — the residual suffix beyond `level` is
-     * descended into via the same `.flatMap`-based {@link pathToFoldAccessorExpr}
-     * the non-override branch already uses, so no depth the fold plan declares
-     * is silently dropped. */
+     * descended into via the same nested-loop emission the non-override branch
+     * already uses, so no depth the fold plan declares is silently dropped.
+     * Ancestor bindings inside `level` itself have no runtime loop variable
+     * (the paginated merge already flattened across them), so only the
+     * residual's OWN ancestor crossings are addressable for threading here. */
     const buildFoldMergeLines = (dataVarName, itemsOverride) => {
         const lines = [];
         for (const [planIndex, foldPlan] of singlePrimaryFoldPlans.entries()) {
             const primaryStep = actionSteps[foldPlan.primaryStepIndex];
             if (!primaryStep)
                 continue;
-            const primaryItems = objectItemsAtPath(primaryStep.capture.responseBody, foldPlan.primaryArrayPath);
+            const primaryItemsWithAncestors = objectItemsWithAncestorsAtPath(primaryStep.capture.responseBody, foldPlan.primaryArrayPath);
             const primaryArrType = foldArrayAssertionType(foldPlan.primaryArrayPath);
             const planSuffix = singlePrimaryFoldPlans.length > 1 ? String(planIndex) : "";
-            const foldItemsVar = `foldItems${planSuffix}`;
-            const foldItemsExpr = itemsOverride
+            const itemVar = `item${planSuffix}`;
+            const residualPath = itemsOverride
                 ? (() => {
-                    const { expr, level } = itemsOverride;
+                    const { level } = itemsOverride;
                     const levelPrefixesPrimaryArrayPath = level.length <= foldPlan.primaryArrayPath.length &&
                         level.every((segment, i) => segment === foldPlan.primaryArrayPath[i]);
                     if (!levelPrefixesPrimaryArrayPath) {
                         throw new Error(`emitContractTs: fold plan primary array path ${foldPlan.primaryArrayPath.join(".")} no longer extends the paginated collection's own array path ${level.join(".")} — the fold plan and this emitter have drifted out of sync`);
                     }
-                    // The residual already carries its own leading
-                    // ARRAY_WILDCARD_SEGMENT whenever it crosses the array boundary
-                    // `level` itself sits at (by construction, since `level` names
-                    // an array path) — `expr` stands in for that same array, so
-                    // pathToFoldAccessorExpr's own flatMap over `expr` consumes it;
-                    // prepending a second one here would double-flatten.
-                    const residualPath = foldPlan.primaryArrayPath.slice(level.length);
-                    if (residualPath.length === 0)
-                        return expr;
-                    const itemTypeExpr = `${pathAccessTypeExpr(`${pascal}Response`, level)}[number]`;
-                    return pathToFoldAccessorExpr(`(${expr} as ${itemTypeExpr}[])`, residualPath);
+                    return foldPlan.primaryArrayPath.slice(level.length);
                 })()
-                : pathToFoldAccessorExpr(`(${dataVarName} as ${primaryArrType})`, foldPlan.primaryArrayPath);
-            const itemVar = `item${planSuffix}`;
-            lines.push(`    const ${foldItemsVar} = ${foldItemsExpr};`, `    for (const ${itemVar} of ${foldItemsVar}) {`);
+                : foldPlan.primaryArrayPath;
+            const { ancestorOpenLines, itemOpenLines, itemCloseLines, ancestorCloseLines, ancestorVars } = itemsOverride
+                ? pathToFoldLoopLines(residualPath.length === 0
+                    ? itemsOverride.expr
+                    : `(${itemsOverride.expr} as ${pathAccessTypeExpr(`${pascal}Response`, itemsOverride.level)}[number][])`, residualPath, itemVar, "    ", planSuffix)
+                : pathToFoldLoopLines(`(${dataVarName} as ${primaryArrType})`, foldPlan.primaryArrayPath, itemVar, "    ", planSuffix);
+            // Ancestor bindings within `itemsOverride.level` (if any) have no
+            // runtime loop variable, since the paginated merge already flattened
+            // across them — only the trailing `residualPath.length` ancestor
+            // crossings correspond to `ancestorVars` above, so slice the
+            // design-time ancestor chain to match.
+            const residualAncestorCount = residualPath.filter((s) => s === ARRAY_WILDCARD_SEGMENT).length;
+            lines.push(...ancestorOpenLines);
+            // Chain fetches for targets whose parameterized URL never interpolates
+            // `itemVar` are spliced here, above the item loop but inside the
+            // ancestor loop(s) — fetched once per ancestor tuple and reused by
+            // every descendant item's join/merge, mirroring
+            // emitMultiStepExecuteHttp's identical hoist (see its own comment).
+            const hoistedChainLines = [];
+            // Every target's join/merge — plus any non-hoistable target's own
+            // chain fetch — goes here, spliced inside the item loop.
+            const itemScopedLines = [];
+            const itemVarRefPattern = new RegExp(`\\$\\{${itemVar}[.[]`);
             for (const [targetIndex, target] of foldPlan.targets.entries()) {
-                const firstItem = primaryItems?.[target.primaryMatchedItemIndex];
-                if (!firstItem) {
+                const matchedPrimaryItem = primaryItemsWithAncestors[target.primaryMatchedItemIndex];
+                if (!matchedPrimaryItem) {
                     throw new Error(`emitContractTs: fold plan primary step ${foldPlan.primaryStepIndex} no longer resolves an object array at ${foldPlan.primaryArrayPath.join(".")} — the fold plan and this emitter have drifted out of sync`);
                 }
+                const { item: firstItem, ancestors: fullAncestors } = matchedPrimaryItem;
+                const residualAncestors = fullAncestors.slice(fullAncestors.length - residualAncestorCount);
+                const ancestorObjByVar = new Map(ancestorVars.map((varName, idx) => [varName, residualAncestors[idx]]));
+                const threadingScopes = [
+                    { varName: itemVar, obj: firstItem },
+                    ...ancestorVars.map((varName) => ({ varName, obj: ancestorObjByVar.get(varName) })),
+                ];
                 const suffix = foldPlan.targets.length > 1 ? `${planSuffix}${targetIndex}` : planSuffix;
-                const joinAccessor = (field) => `${itemVar}${pathToAccessor(field.split("."), { assertNonNull: false })}`;
+                const scopedAccessor = (varName, field) => `${varName}${pathToAccessor(field.split("."), { assertNonNull: false })}`;
+                const joinAccessor = (field) => scopedAccessor(itemVar, field);
                 // Same word-boundary-anchored swap emitMultiStepExecuteHttp's own
                 // `parameterize` performs — a plain split/join would also rewrite
                 // unrelated substrings that happen to contain the join value.
                 //
                 // Parameterizes off EVERY per-item field this specific chain hop's
-                // own captured request actually varies on (via findThreadedJoinFields),
-                // not just `target.joinFields` — `target.joinFields` names the field
-                // used to MATCH the drill's RESPONSE back onto the primary item (see
+                // own captured request actually varies on (via findThreadedJoinFields,
+                // searched across the item AND every ancestor binding), not just
+                // `target.joinFields` — `target.joinFields` names the field used to
+                // MATCH the drill's RESPONSE back onto the primary item (see
                 // emitFoldMatchAndMergeLines), which for a spec-declared foldReturn
                 // can legitimately be a field the request never carries at all (e.g.
                 // an `id` echoed only in the response, while the request is keyed by
                 // an unrelated field like a package code). Building the URL from only
                 // `target.joinFields` in that case would leave it unparameterized —
-                // every item would fetch the SAME first-captured URL.
+                // every item would fetch the SAME first-captured URL. Searching
+                // ancestor scopes too is what lets a param that only lives on a
+                // parent object (e.g. a group id) resolve at all.
                 const parameterizeUrl = (rawUrl, chainCapture) => {
                     const withBase = baseUrl.length > 0 && rawUrl.startsWith(baseUrl)
                         ? `\${context.baseUrl}${rawUrl.slice(baseUrl.length)}`
                         : rawUrl;
-                    const threadedFields = new Set([
-                        ...target.joinFields,
-                        ...findThreadedJoinFields(firstItem, chainCapture),
+                    const threadedFields = dedupeThreadedFields([
+                        ...target.joinFields.map((field) => ({ varName: itemVar, field })),
+                        ...findThreadedJoinFields(threadingScopes, chainCapture, actionSteps.map((s) => s.capture)),
                     ]);
-                    return [...threadedFields].reduce((acc, field) => {
-                        const value = readValueAtPath(firstItem, field.split("."));
+                    const result = threadedFields.reduce((acc, { varName, field }) => {
+                        const scopeObj = varName === itemVar ? firstItem : ancestorObjByVar.get(varName);
+                        const value = readValueAtPath(scopeObj, field.split("."));
                         const stringValue = typeof value === "string" && value.length > 0
                             ? value
                             : typeof value === "number" || typeof value === "boolean"
@@ -6697,28 +7080,49 @@ const httpClient = createHttpClient({ schema: ${pascal}ResponseSchema, bottlenec
                                 : null;
                         if (stringValue === null)
                             return acc;
-                        return acc.replace(new RegExp(`\\b${stringValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g"), `\${${joinAccessor(field)}}`);
+                        return acc.replace(new RegExp(`\\b${stringValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g"), `\${${scopedAccessor(varName, field)}}`);
                     }, withBase);
+                    assertNoFrozenVaryingDrillParams("emitContractTs", chainCapture, result, actionSteps.map((s) => s.capture));
+                    return result;
                 };
+                const chainLines = [];
+                // True once any chain step's parameterized URL actually ends up
+                // referencing `itemVar`, off the SAME `parameterizeUrl` call the
+                // request literally interpolates — see emitMultiStepExecuteHttp's
+                // identical `referencesItemVar` for why this can't disagree with
+                // what's emitted. `ancestorVars.length === 0` means there's no
+                // ancestor loop to hoist into (a flat, single-level fold), so it's
+                // treated as item-scoped too — flat folds must keep emitting
+                // byte-identical code.
+                let referencesItemVar = ancestorVars.length === 0;
                 for (const chainIndex of target.chain) {
                     const chainStep = actionSteps[chainIndex];
                     if (!chainStep)
                         continue;
                     const url = parameterizeUrl(chainStep.capture.url, chainStep.capture);
+                    if (itemVarRefPattern.test(url))
+                        referencesItemVar = true;
                     const schemaExpr = inferZodSchema(chainStep.capture.responseBody, 0, "", {
                         looseServerResponse: true,
                         aggregateUnitBasisFindingsByPath: groupAggregateUnitBasisFindingsByPath([
                             chainStep.capture.responseBody,
                         ]),
                     });
-                    lines.push(`      const ${chainStep.varName} = (await httpClient(\`${url}\`, {`, `        method: ${JSON.stringify(chainStep.capture.method)},`, `        schema: ${schemaExpr},`, `      })) as Record<string, unknown>;`);
+                    chainLines.push(`      const ${chainStep.varName} = (await httpClient(\`${url}\`, {`, `        method: ${JSON.stringify(chainStep.capture.method)},`, `        schema: ${schemaExpr},`, `      })) as Record<string, unknown>;`);
                 }
                 const terminalStep = actionSteps[target.chainTerminalIndex];
                 if (!terminalStep)
                     continue;
-                lines.push(...emitFoldMatchAndMergeLines(terminalStep, target, itemVar, suffix, joinAccessor));
+                const matchLines = emitFoldMatchAndMergeLines(terminalStep, target, itemVar, suffix, joinAccessor);
+                if (referencesItemVar) {
+                    itemScopedLines.push(...chainLines, ...matchLines);
+                }
+                else {
+                    hoistedChainLines.push(...chainLines);
+                    itemScopedLines.push(...matchLines);
+                }
             }
-            lines.push(`    }`, "");
+            lines.push(...hoistedChainLines, ...itemOpenLines, ...itemScopedLines, ...itemCloseLines, ...ancestorCloseLines, "");
         }
         return lines;
     };