@enricai/barnacle 1.12.63 → 1.12.65

package/dist/scripts/recon-generate.js

@@ -4493,7 +4493,15 @@ function replaceGuardedAgainstExistingPlaceholders(text, pattern, bindingByValue
  * first, and the literal is gone by the time the KV pass runs — masking
  * payload precedence on every call after the one that scraped it.
  */
-function interpolateStateValues(template, priorSteps, targetCapture, payloadAccessorByValue = new Map(), isJsonBody = false, producerBoundaryBindings = new Map(), stepIndex = -1, topLevelPayloadKvValues = new Set()) {
+function interpolateStateValues(template, priorSteps, targetCapture, payloadAccessorByValue = new Map(), isJsonBody = false, producerBoundaryBindings = new Map(), stepIndex = -1, topLevelPayloadKvValues = new Set(), 
+// A fold target's own join-field value (see `joinFieldValuesByStep` in
+// `emitMultiStepExecuteHttp`) must stay a literal here — binding it to a
+// prior step's produced state var (e.g. `${productId}`, always the FIRST
+// primary item's value) freezes every per-item drill call onto that one
+// item; the fold loop's own later `parameterize` pass is what rebinds the
+// literal to `${item.<field>}` per iteration, but only if the literal
+// text survives this pass untouched.
+excludedJoinFieldValues = new Set()) {
     const stateBindings = deriveStateVarByValue(priorSteps, targetCapture);
     const bindingByValue = new Map();
     for (const [value, accessor] of payloadAccessorByValue) {
@@ -4508,6 +4516,8 @@ function interpolateStateValues(template, priorSteps, targetCapture, payloadAcce
             continue;
         if (topLevelPayloadKvValues.has(value) && !isProducerStep)
             continue;
+        if (excludedJoinFieldValues.has(value) && !isProducerStep)
+            continue;
         bindingByValue.set(value, `\${${binding.varName}}`);
         sourceNameByValue.set(value, binding.sourceName);
         if (binding.restricted)
@@ -5525,7 +5535,7 @@ pascalName = null) {
         // length/chain-eligibility scoping doesn't happen to catch the coincidence.
         const url = (0, capture_filters_1.isZeroVarianceRepeatCapture)(cap, actions.map((a) => a.capture))
             ? cap.url
-            : interpolateStateValues(cap.url, prior, cap, payloadAccessorByValue, false, producerBoundaryBindings, i);
+            : interpolateStateValues(cap.url, prior, cap, payloadAccessorByValue, false, producerBoundaryBindings, i, new Set(), joinFieldValuesByStep.get(i) ?? new Set());
         // Form-schema substitution runs first on the raw recon body so its
         // field-id-anchored matches see the original JSON. State-threading and
         // payload key-value passes then run on top. Option-id substitution runs
@@ -5595,7 +5605,7 @@ pascalName = null) {
             ? applyUrlParamPayloadSubstitutions(rawBodyWithProducerBoundary, parsedBody, urlParamBindings)
             : rawBodyWithProducerBoundary;
         const bodyAfterStateAndKv = rawBodyWithUrlParams
-            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies)
+            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues, joinFieldValuesByStep.get(i) ?? new Set()), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies)
             : "";
         // Mechanism A — generic (plain-JSON, wire-key-anchored) dropdown label→code
         // rewrite. Runs AFTER interpolateStateValues + the payload-KV pass, not
@@ -6067,11 +6077,27 @@ pascalName = null) {
                         itemVarRefPattern.test(paramBody)) {
                         referencesItemVar = true;
                     }
-                    chainLines.push(`      const ${chainStep.varName} = (await httpClient(\`${paramUrl}\`, {`, `        method: ${JSON.stringify(chainRendered.method)},`);
+                    // Only bind this hop's response to a local when something actually
+                    // reads it back: the chain terminal (consumed by
+                    // emitFoldMatchAndMergeLines via `terminalStep.varName` below) or a
+                    // non-header `produces` entry some later step's request threads
+                    // (header threading goes through httpClient's own `bind` store, not
+                    // a local — see the header branch below). A hop chained purely to
+                    // unlock a later request (e.g. it sets server-side state via a
+                    // header token) has no reader for its own response and must stay
+                    // unbound, or the emitted loop declares a variable nothing
+                    // references (Biome noUnusedVariables).
+                    const isChainTerminal = chainIndex === target.chainTerminalIndex;
+                    const hasReferencedProduce = chainStep.produces.some((p) => p.kind !== "header" && referencedNames.has(p.name) && !chainDeclared.has(p.name));
+                    const bindsChainResponse = isChainTerminal || hasReferencedProduce;
+                    chainLines.push(bindsChainResponse
+                        ? `      const ${chainStep.varName} = (await httpClient(\`${paramUrl}\`, {`
+                        : `      await httpClient(\`${paramUrl}\`, {`, `        method: ${JSON.stringify(chainRendered.method)},`);
                     const joined = [paramHeaders, paramBody].filter((s) => s !== "").join(" ");
                     if (joined !== "")
                         chainLines.push(`        ${joined}`);
-                    chainLines.push(`        schema: ${chainRendered.schemaExpr},`, `      })) as Record<string, unknown>;`);
+                    chainLines.push(`        schema: ${chainRendered.schemaExpr},`);
+                    chainLines.push(bindsChainResponse ? `      })) as Record<string, unknown>;` : `      });`);
                     for (const p of chainStep.produces) {
                         if (p.kind === "header") {
                             chainUsesHeaderThreading = true;
@@ -8174,7 +8200,26 @@ function compileFoldReturnResultsMatcher(spec) {
 function buildFoldPlanFromSpec(actions, spec, 
 // See detectDrillDownFoldPlan's identical parameter — constrains this
 // function's own primaryStepIndex loop to the same anchor identity.
-primaryIdentityAnchor = null) {
+primaryIdentityAnchor = null, 
+// When given, restricts the loop to this ONE primaryStepIndex instead of
+// scanning every occurrence and keeping only the freshest. Used by
+// mergeSpecPlanOntoSamePrimary to resolve a declared joinFields override
+// independently for EACH re-issued/paginated primary occurrence, since the
+// freshest-wins scan below only ever resolves the LAST occurrence.
+exactPrimaryStepIndex = null, 
+// When given, restricts the matching-drill scan below to candidates whose
+// OWN endpoint (not a later chain hop) matches this key. A single primary
+// occurrence can structurally resolve MULTIPLE independent per-item
+// targets — one per distinct drill endpoint (e.g. a genuinely per-item
+// drill loop where each item's own request lands on the SAME endpoint
+// pattern but a distinct path/endpoint identity) — and this function's own
+// freshest-first scan below `break`s after the FIRST endpoint it resolves,
+// so an unrestricted call can only ever return an override for ONE of
+// them. Used by mergeSpecPlanOntoSamePrimary to resolve the declared
+// joinFields override independently for EACH structural target, keyed by
+// its own drill endpoint, instead of only the one this function's
+// freshest-first scan happens to land on first.
+restrictToDrillEndpointKey = null) {
     const primaryArrayPath = spec.resultsPath.split(".");
     const matchesFoldReturnEndpoint = compileFoldReturnEndpointMatcher(spec);
     // Built once and shared across every primaryStepIndex — see
@@ -8185,6 +8230,9 @@ primaryIdentityAnchor = null) {
     const requestValueIndex = buildRequestValueIndex(actions);
     let freshestPlan = null;
     for (let primaryStepIndex = 0; primaryStepIndex < actions.length; primaryStepIndex++) {
+        if (exactPrimaryStepIndex !== null && primaryStepIndex !== exactPrimaryStepIndex) {
+            continue;
+        }
         if (primaryIdentityAnchor !== null &&
             operationGroupKey(actions[primaryStepIndex].capture) !== primaryIdentityAnchor) {
             continue;
@@ -8213,7 +8261,9 @@ primaryIdentityAnchor = null) {
         // response-only fallback below exists to resolve.
         const matchingDrillStepIndices = [];
         for (let drillStepIndex = primaryStepIndex + 1; drillStepIndex < actions.length; drillStepIndex++) {
-            if (matchesFoldReturnEndpoint(actions[drillStepIndex].capture)) {
+            if (matchesFoldReturnEndpoint(actions[drillStepIndex].capture) &&
+                (restrictToDrillEndpointKey === null ||
+                    endpointKey(actions[drillStepIndex].capture.url) === restrictToDrillEndpointKey)) {
                 matchingDrillStepIndices.push(drillStepIndex);
             }
         }
@@ -8347,6 +8397,26 @@ function isDescendantArrayPath(candidate, base) {
  * spec's own drill indices look independent, so the heuristic's wrong-level
  * guess never survives alongside the corrected one.
  */
+/**
+ * The stable identity of the logical drill-down a {@link FoldTarget}
+ * resolves onto: the endpoint of its chain's TERMINAL call (the response
+ * actually folded — see {@link FoldTarget.chainTerminalIndex}) paired with
+ * the specific array read off that response (see
+ * {@link FoldTarget.chainArrayPath}). Neither piece alone is stable enough to
+ * compare two independently-resolved targets by: `drillStepIndex` (the
+ * chain's ENTRY point) can legitimately differ between the structural
+ * heuristic's own request-threading resolution and a spec's
+ * response-only/upstream-hop resolution even when both terminate at the same
+ * call (see {@link buildFoldPlanFromSpec}'s `entryIndex` docstring); and the
+ * terminal endpoint alone can collide when one response happens to carry TWO
+ * unrelated per-item arrays for two entirely different primaries (e.g. a
+ * combined status response naming both `entries` and `contracts`). Pairing
+ * the terminal's endpoint with the specific array it reads disambiguates
+ * both cases at once.
+ */
+function foldTargetDrillIdentity(actions, target) {
+    return `${endpointKey(actions[target.chainTerminalIndex].capture.url)}\u0000${target.chainArrayPath.join(".")}`;
+}
 function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec, 
 // See detectDrillDownFoldPlan's identical parameter. Threaded into this
 // function's own buildFoldPlanFromSpec call so a spec plan resolved here
@@ -8355,9 +8425,55 @@ function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec,
 primaryIdentityAnchor = null) {
     if (foldReturnSpec === null)
         return [...structuralPlans];
+    // Override joinFields on EVERY structural primary occurrence the spec can
+    // independently resolve at its OWN primaryStepIndex — not just whichever
+    // single occurrence the freshest-wins `specPlan` resolution below happens
+    // to land on. A re-issued/paginated primary (same endpoint, multiple
+    // captures) produces one independent structural plan per occurrence; each
+    // must get the declared override, not just the freshest one.
+    const structuralPlansWithPerOccurrenceOverrides = structuralPlans.map((plan) => {
+        // Resolved once per structural TARGET (keyed on that target's own drill
+        // endpoint), not once for the whole primary occurrence: buildFoldPlanFromSpec's
+        // freshest-first scan `break`s after the first drill endpoint it resolves, so a
+        // single unrestricted call can only ever produce an override for ONE of a
+        // primary's structural targets even when it has several (e.g. a genuinely
+        // per-item drill loop resolving one independent target per item, each at its
+        // own endpoint). See buildFoldPlanFromSpec's restrictToDrillEndpointKey docstring.
+        const mergedTargets = plan.targets.map((target) => {
+            const ownSpecPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor, plan.primaryStepIndex, endpointKey(actions[target.drillStepIndex].capture.url));
+            if (ownSpecPlan === null ||
+                JSON.stringify(ownSpecPlan.primaryArrayPath) !== JSON.stringify(plan.primaryArrayPath)) {
+                return target;
+            }
+            // ownSpecPlan was resolved with restrictToDrillEndpointKey pinned to
+            // this target's OWN drill endpoint, so its single target (see
+            // buildFoldPlanFromSpec's `targets: [{...}]` literal — it never
+            // returns more than one) IS the spec's resolution of this restricted
+            // endpoint by construction. Matching it back to `target` via
+            // foldTargetDrillIdentity is not just redundant but actively wrong: a
+            // multi-hop drill chain can make the spec's forward walk
+            // (buildFoldPlanFromSpec's computeFoldChain resolution) land on a
+            // different chainTerminalIndex/chainArrayPath than the structural
+            // heuristic did for the exact same restricted endpoint, so the
+            // identity lookup misses and the declared joinFields override is
+            // silently dropped in favor of the heuristic's structural guess.
+            const specTarget = ownSpecPlan.targets[0];
+            return specTarget === undefined ? target : { ...target, joinFields: specTarget.joinFields };
+        });
+        // A spec-declared target the heuristic missed entirely (an independent
+        // drill-down at a NEW endpoint) is still found via the original
+        // unrestricted resolution, which is free to land on any endpoint.
+        const ownSpecPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor, plan.primaryStepIndex);
+        const existingDrillIdentities = new Set(plan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+        const newTargets = ownSpecPlan !== null &&
+            JSON.stringify(ownSpecPlan.primaryArrayPath) === JSON.stringify(plan.primaryArrayPath)
+            ? ownSpecPlan.targets.filter((target) => !existingDrillIdentities.has(foldTargetDrillIdentity(actions, target)))
+            : [];
+        return { ...plan, targets: [...mergedTargets, ...newTargets] };
+    });
     const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor);
     if (specPlan === null)
-        return [...structuralPlans];
+        return structuralPlansWithPerOccurrenceOverrides;
     const specPrimaryEndpointKey = endpointKey(actions[specPlan.primaryStepIndex].capture.url);
     // Deliberately keyed on the RAW primaryStepIndex (not endpoint identity):
     // this branch trusts the structural target's own chain/drillArrayPath and
@@ -8367,46 +8483,73 @@ primaryIdentityAnchor = null) {
     // different index) may have matched a different item entirely, so it must
     // fall through to the wholesale-replace (sharedDrillPlan) or union
     // (consumedPrimarySteps) handling below instead of merging by identity.
-    const samePrimaryPlan = structuralPlans.find((plan) => plan.primaryStepIndex === specPlan.primaryStepIndex &&
+    const samePrimaryPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => plan.primaryStepIndex === specPlan.primaryStepIndex &&
         JSON.stringify(plan.primaryArrayPath) === JSON.stringify(specPlan.primaryArrayPath));
     if (samePrimaryPlan !== undefined) {
-        // A drillStepIndex the structural heuristic ALSO resolved keeps its
-        // structurally-resolved chain/drillArrayPath (already proven to reach
-        // real per-item data), but its `joinFields` is overridden to the spec's
-        // declared value — the heuristic's own joinFields only prove a field
-        // threads INTO the drill's REQUEST, which says nothing about whether
-        // that same field can be found on the drill's RESPONSE to match it back
-        // onto a primary item (see emitFoldMatchAndMergeLines). A flow author
-        // declaring `joinFields` on a foldReturn is asserting exactly that: this
-        // is the field their drill-down's RESPONSE actually carries.
-        const specTargetsByDrillStepIndex = new Map(specPlan.targets.map((target) => [target.drillStepIndex, target]));
-        return structuralPlans.map((plan) => {
+        // A structural target serving the SAME drill-down the spec declares
+        // keeps its structurally-resolved chain/drillArrayPath (already proven
+        // to reach real per-item data), but its `joinFields` is overridden to
+        // the spec's declared value — the heuristic's own joinFields only prove
+        // a field threads INTO the drill's REQUEST, which says nothing about
+        // whether that same field can be found on the drill's RESPONSE to match
+        // it back onto a primary item (see emitFoldMatchAndMergeLines). A flow
+        // author declaring `joinFields` on a foldReturn is asserting exactly
+        // that: this is the field their drill-down's RESPONSE actually carries.
+        // Matched by the drill's ENDPOINT IDENTITY (the same identity
+        // scanPrimaryCandidateGroups' own `alreadyTargetedSameEndpoint` check
+        // uses), not raw drillStepIndex equality: the spec's own entryIndex
+        // resolution (resolveSpecMatchedPrimaryItemIndexAlongChain) and the
+        // heuristic's own request-threading scan can each land on a different,
+        // but equally valid, occurrence of the SAME re-issued/paginated drill
+        // endpoint — raw-index equality only happened to override when both
+        // resolutions picked the identical occurrence, silently leaving every
+        // other occurrence's joinFields un-overridden. Keyed on each target's
+        // {@link foldTargetDrillIdentity} — the terminal endpoint paired with the
+        // specific array it reads — rather than `drillStepIndex`: a spec's
+        // declared join value often resolves only through an upstream entry hop
+        // (e.g. a header-threaded token) that isn't the endpointPattern-matched
+        // call itself, so its `drillStepIndex` (== that entry hop) can
+        // legitimately differ from the structural heuristic's own
+        // `drillStepIndex` (its own, possibly different, threading entry point)
+        // even when both chains terminate at the exact same logical drill-down
+        // call and array.
+        const specTargetsByDrillIdentity = new Map(specPlan.targets.map((target) => [foldTargetDrillIdentity(actions, target), target]));
+        return structuralPlansWithPerOccurrenceOverrides.map((plan) => {
             if (plan !== samePrimaryPlan)
                 return plan;
             const mergedTargets = plan.targets.map((target) => {
-                const specTarget = specTargetsByDrillStepIndex.get(target.drillStepIndex);
+                const specTarget = specTargetsByDrillIdentity.get(foldTargetDrillIdentity(actions, target));
                 return specTarget === undefined ? target : { ...target, joinFields: specTarget.joinFields };
             });
-            const existingDrillStepIndexes = new Set(plan.targets.map((target) => target.drillStepIndex));
-            const newTargets = specPlan.targets.filter((target) => !existingDrillStepIndexes.has(target.drillStepIndex));
+            const existingDrillIdentities = new Set(plan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+            const newTargets = specPlan.targets.filter((target) => !existingDrillIdentities.has(foldTargetDrillIdentity(actions, target)));
             return { ...plan, targets: [...mergedTargets, ...newTargets] };
         });
     }
     // No exact (primaryStepIndex, primaryArrayPath) match, but a structural
     // plan on the SAME primaryStepIndex may still have independently detected
-    // a target at the SAME drillStepIndex a spec target names — just at the
-    // wrong array level (e.g. a shallower structural guess that happens to
-    // share the spec's drill-down call). That structural target's own
-    // primaryArrayPath/drillArrayPath/joinFields describe the heuristic's
-    // guess, not the flow author's declaration, so the spec target replaces
-    // it wholesale rather than being discarded by the mismatched-array-path
-    // branch below or partially merged as if the array level matched.
-    const specDrillStepIndices = new Set(specPlan.targets.map((target) => target.drillStepIndex));
-    const sharedDrillPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
-        plan.targets.some((target) => specDrillStepIndices.has(target.drillStepIndex)));
+    // a target at the SAME drill ENDPOINT+array a spec target names — just at
+    // the wrong array level (e.g. a shallower structural guess that happens to
+    // share the spec's drill-down call). Matched by {@link
+    // foldTargetDrillIdentity} (see the samePrimaryPlan branch above for why
+    // the terminal+array, not the entry `drillStepIndex` alone, is the stable
+    // identity to compare on) — not raw drillStepIndex equality:
+    // buildFoldPlanFromSpec's own entryIndex resolution and the structural
+    // heuristic's request-threading scan can each land on a different, but
+    // equally valid, occurrence/hop of the SAME endpoint (or the same single
+    // occurrence reached via a different chain entry point), and raw-index
+    // equality only happens to hold when both resolutions pick the identical
+    // index. That structural target's own primaryArrayPath/drillArrayPath/
+    // joinFields describe the heuristic's guess, not the flow author's
+    // declaration, so the spec target replaces it wholesale rather than being
+    // discarded by the mismatched-array-path branch below or partially merged
+    // as if the array level matched.
+    const specDrillIdentities = new Set(specPlan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+    const sharedDrillPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+        plan.targets.some((target) => specDrillIdentities.has(foldTargetDrillIdentity(actions, target))));
     if (sharedDrillPlan !== undefined) {
-        const remainingTargets = sharedDrillPlan.targets.filter((target) => !specDrillStepIndices.has(target.drillStepIndex));
-        const otherPlans = structuralPlans.filter((plan) => plan !== sharedDrillPlan);
+        const remainingTargets = sharedDrillPlan.targets.filter((target) => !specDrillIdentities.has(foldTargetDrillIdentity(actions, target)));
+        const otherPlans = structuralPlansWithPerOccurrenceOverrides.filter((plan) => plan !== sharedDrillPlan);
         const keptStructuralPlans = remainingTargets.length === 0
             ? otherPlans
             : [...otherPlans, { ...sharedDrillPlan, targets: remainingTargets }];
@@ -8421,10 +8564,13 @@ primaryIdentityAnchor = null) {
     // the independence guard below would otherwise do, since a
     // level-correcting spec's own drill indices can look entirely
     // independent) or silently dropped by the mismatched-array-path checks.
-    const supersededShallowerPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+    const supersededShallowerPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
         isDescendantArrayPath(specPlan.primaryArrayPath, plan.primaryArrayPath));
     if (supersededShallowerPlan !== undefined) {
-        return [...structuralPlans.filter((plan) => plan !== supersededShallowerPlan), specPlan];
+        return [
+            ...structuralPlansWithPerOccurrenceOverrides.filter((plan) => plan !== supersededShallowerPlan),
+            specPlan,
+        ];
     }
     // Keyed by the (primaryStepIndex, primaryArrayPath) pair, not
     // primaryStepIndex alone — a structural plan only ever consumed ITS OWN
@@ -8441,7 +8587,7 @@ primaryIdentityAnchor = null) {
     // contends for.
     const consumedIndices = new Set();
     const consumedPrimarySteps = new Set();
-    for (const plan of structuralPlans) {
+    for (const plan of structuralPlansWithPerOccurrenceOverrides) {
         const planPrimaryEndpointKey = endpointKey(actions[plan.primaryStepIndex].capture.url);
         consumedPrimarySteps.add(`${planPrimaryEndpointKey}:${JSON.stringify(plan.primaryArrayPath)}`);
         for (const target of plan.targets) {
@@ -8452,19 +8598,27 @@ primaryIdentityAnchor = null) {
         !consumedPrimarySteps.has(`${specPrimaryEndpointKey}:${JSON.stringify(specPlan.primaryArrayPath)}`) &&
         specPlan.targets.every((target) => target.chain.every((chainIndex) => !consumedIndices.has(chainIndex)));
     if (specConsumesOnlyItsOwnIndices)
-        return [...structuralPlans, specPlan];
+        return [...structuralPlansWithPerOccurrenceOverrides, specPlan];
     // The spec's primary endpoint/array is already consumed by a structural
     // plan on a DIFFERENT capture of the same re-issued primary operation
     // (paginated primary), but its own target chains touch no index that plan
     // already depends on — this is the same identity, not a raw-index
     // coincidence, so union the spec's targets onto it rather than silently
-    // dropping a declaration the flow author explicitly wrote.
-    const sameIdentityPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+    // dropping a declaration the flow author explicitly wrote. Membership in
+    // "already covered" is decided by {@link foldTargetDrillIdentity} (see the
+    // samePrimaryPlan branch above for why the terminal+array, not the entry
+    // `drillStepIndex` alone, is the stable identity) — not raw drillStepIndex
+    // equality. A spec target sharing a structural target's drill identity is
+    // a re-declaration of that SAME drill-down (handled as a wholesale replace
+    // by sharedDrillPlan above), not an independent one to union — so this
+    // only ever unions genuinely new endpoints onto an already-identified
+    // primary.
+    const sameIdentityPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
         JSON.stringify(plan.primaryArrayPath) === JSON.stringify(specPlan.primaryArrayPath) &&
-        specPlan.targets.every((target) => !plan.targets.some((t) => t.drillStepIndex === target.drillStepIndex)));
+        specPlan.targets.every((target) => !plan.targets.some((t) => foldTargetDrillIdentity(actions, t) === foldTargetDrillIdentity(actions, target))));
     if (sameIdentityPlan === undefined)
-        return [...structuralPlans];
-    return structuralPlans.map((plan) => plan === sameIdentityPlan ? { ...plan, targets: [...plan.targets, ...specPlan.targets] } : plan);
+        return [...structuralPlansWithPerOccurrenceOverrides];
+    return structuralPlansWithPerOccurrenceOverrides.map((plan) => plan === sameIdentityPlan ? { ...plan, targets: [...plan.targets, ...specPlan.targets] } : plan);
 }
 /**
  * The single fold-plan entry point: {@link detectDrillDownFoldPlan}'s
@@ -9836,7 +9990,19 @@ const httpClient = createHttpClient({ schema: ${pascal}ResponseSchema, bottlenec
                             chainStep.capture.responseBody,
                         ]),
                     });
-                    chainLines.push(`      const ${chainStep.varName} = (await httpClient(\`${url}\`, {`, `        method: ${JSON.stringify(chainStep.capture.method)},`, `        schema: ${schemaExpr},`, `      })) as Record<string, unknown>;`);
+                    // This emitter never renders a per-hop `produces` accessor (unlike
+                    // emitMultiStepExecuteHttp's identical chain loop) — only the
+                    // chain terminal's response is ever read, via
+                    // `terminalStep.varName` inside emitFoldMatchAndMergeLines below.
+                    // A non-terminal hop chained purely to unlock a later request
+                    // (e.g. it sets server-side state via a threaded header) has no
+                    // reader for its own response, so binding it to a local declares a
+                    // variable nothing references (Biome noUnusedVariables).
+                    const bindsChainResponse = chainIndex === target.chainTerminalIndex;
+                    chainLines.push(bindsChainResponse
+                        ? `      const ${chainStep.varName} = (await httpClient(\`${url}\`, {`
+                        : `      await httpClient(\`${url}\`, {`, `        method: ${JSON.stringify(chainStep.capture.method)},`, `        schema: ${schemaExpr},`);
+                    chainLines.push(bindsChainResponse ? `      })) as Record<string, unknown>;` : `      });`);
                 }
                 const terminalStep = actionSteps[target.chainTerminalIndex];
                 if (!terminalStep)