@enricai/barnacle 1.12.51 → 1.12.54

package/dist/scripts/recon-generate-multicall-fixture.js

@@ -21,12 +21,18 @@ exports.buildMulticallTwoIndependentPrimariesSecondHeaderThreadedActionSteps = b
 exports.buildMulticallSingleShotSearchHeuristicAndSpecTwoTargetActionSteps = buildMulticallSingleShotSearchHeuristicAndSpecTwoTargetActionSteps;
 exports.buildMulticallTwoOccurrencesSamePrimaryDistinctDrillsActionSteps = buildMulticallTwoOccurrencesSamePrimaryDistinctDrillsActionSteps;
 exports.buildMulticallNestedGroupedDrillDownMultiGroupActionSteps = buildMulticallNestedGroupedDrillDownMultiGroupActionSteps;
+exports.buildMulticallTwoIndependentPrimariesNestedFieldLoopScopeActionSteps = buildMulticallTwoIndependentPrimariesNestedFieldLoopScopeActionSteps;
 exports.buildMulticallNestedGroupedDrillDownTwoScopeParamsActionSteps = buildMulticallNestedGroupedDrillDownTwoScopeParamsActionSteps;
 exports.buildMulticallNestedGroupedDrillDownAncestorOnlyParamsActionSteps = buildMulticallNestedGroupedDrillDownAncestorOnlyParamsActionSteps;
 exports.buildMulticallNestedGroupedDrillDownScopeCoincidentParamActionSteps = buildMulticallNestedGroupedDrillDownScopeCoincidentParamActionSteps;
 exports.buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamActionSteps = buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamActionSteps;
+exports.buildMulticallNestedGroupedDrillDownSparseFirstElementAncestorScopedParamActionSteps = buildMulticallNestedGroupedDrillDownSparseFirstElementAncestorScopedParamActionSteps;
+exports.buildMulticallNestedGroupedDrillDownAncestorItemValueCoincidenceActionSteps = buildMulticallNestedGroupedDrillDownAncestorItemValueCoincidenceActionSteps;
+exports.buildMulticallNestedGroupedDrillDownTwoLevelNestedAncestorFieldActionSteps = buildMulticallNestedGroupedDrillDownTwoLevelNestedAncestorFieldActionSteps;
 exports.buildMulticallNestedGroupedDrillDownDualScopeCoincidentParamsActionSteps = buildMulticallNestedGroupedDrillDownDualScopeCoincidentParamsActionSteps;
 exports.buildMulticallNestedGroupedDrillDownDualItemLiteralDistinctSubpathAncestorScopedParamsActionSteps = buildMulticallNestedGroupedDrillDownDualItemLiteralDistinctSubpathAncestorScopedParamsActionSteps;
+exports.buildMulticallAncestorOnlyMultiTargetDrillDownActionSteps = buildMulticallAncestorOnlyMultiTargetDrillDownActionSteps;
+exports.buildMulticallAncestorScopedDualThreadedFieldDrillDownActionSteps = buildMulticallAncestorScopedDualThreadedFieldDrillDownActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownNumericJoinActionSteps = buildMulticallSingleShotSearchDrillDownNumericJoinActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownPathThreadedJoinActionSteps = buildMulticallSingleShotSearchDrillDownPathThreadedJoinActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownNestedJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownNestedJoinFieldActionSteps;
@@ -67,6 +73,7 @@ exports.buildMulticallSingleShotSearchDrillDownConstantParamCoincidentValueActio
 exports.buildMulticallSingleShotSearchDrillDownBoundConstantParamCoincidentValueActionSteps = buildMulticallSingleShotSearchDrillDownBoundConstantParamCoincidentValueActionSteps;
 exports.buildManyRepeatPagedListingDrillWithNoiseVariantActionSteps = buildManyRepeatPagedListingDrillWithNoiseVariantActionSteps;
 exports.buildSessionHeartbeatNoiseStep = buildSessionHeartbeatNoiseStep;
+exports.buildMulticallOrdersLineItemPromoEligibilityActionSteps = buildMulticallOrdersLineItemPromoEligibilityActionSteps;
 const date_fns_1 = require("date-fns");
 function buildCapture(overrides) {
     return {
@@ -800,6 +807,85 @@ function buildMulticallNestedGroupedDrillDownMultiGroupActionSteps() {
     ];
 }
 const CATALOG_ENTRY_DETAILS_URL = "https://api.example.com/catalog/entries/details";
+/**
+ * TWO fully independent fold plans in one action-step sequence, each bound to
+ * its OWN loop-variable name (`item0`/`item1` — every loop var is suffixed by
+ * plan index once more than one independent plan resolves): a flat,
+ * heuristically-detected primary/drill pair (products/reviews, `item0`) and a
+ * nested GROUPED primary/drill pair (sections/entries, `item1`) whose
+ * per-item join field lives under a NESTED path (`identifiers.code`).
+ *
+ * That nested path is the exact shape that regresses the fold-hoist decision
+ * in `emitMultiStepExecuteHttp`/`buildFoldMergeLines`: `scopedAccessor`/
+ * `unknownValueAccessor` wrap every non-leaf hop of a nested field path in a
+ * `(item1.identifiers as Record<string, unknown>)` cast, so the drill's
+ * itemVar reference renders as `${(item1.identifiers...` rather than
+ * `${item1...}`. An `itemVarRefPattern` anchored on `${itemVar` immediately
+ * following the interpolation brace misses that cast-wrapped shape entirely,
+ * wrongly concludes the drill never references `item1`, and hoists it above
+ * `item1`'s own loop — into a scope where `item1` is undeclared — even
+ * though `entries/details`' `code` value differs per item (`e1`/`e2`), which
+ * is only resolvable per-item, never once per group.
+ *
+ * Regression coverage: `item1`'s own chain fetch must stay lexically INSIDE
+ * `item1`'s own loop, and must never appear inside `item0`'s loop (and vice
+ * versa) — even though both plans' drills structurally target the same
+ * `entries/details` endpoint shape, so a scope-defeating fold-hoist bug has
+ * every opportunity to bleed one loop's bound identifier into the other's
+ * request body.
+ */
+function buildMulticallTwoIndependentPrimariesNestedFieldLoopScopeActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                products: [{ productId: "p1" }, { productId: "p2" }],
+            },
+            timestamp: "2025-05-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_PRICING_URL,
+            requestPostData: '{"productId":"p1"}',
+            responseBody: { reviews: [{ productId: "p1", rating: 5 }] },
+            timestamp: "2025-05-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "sec1",
+                        entries: [
+                            { entryId: "e1", identifiers: { code: "code-e1" } },
+                            { entryId: "e2", identifiers: { code: "code-e2" } },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-05-01T00:00:02Z",
+        }),
+        buildStep("r3", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=code-e1`,
+            requestPostData: null,
+            responseBody: { details: [{ entryId: "e1", description: "d-e1" }] },
+            timestamp: "2025-05-01T00:00:03Z",
+        }),
+        buildStep("r4", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=code-e2`,
+            requestPostData: null,
+            responseBody: { details: [{ entryId: "e2", description: "d-e2" }] },
+            timestamp: "2025-05-01T00:00:04Z",
+        }),
+        buildStep("r5", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=zzz-unrelated`,
+            requestPostData: null,
+            responseBody: { details: [] },
+            timestamp: "2025-05-01T00:00:05Z",
+        }),
+    ];
+}
 /**
  * A grouped, nested-primary drill-down whose drilled endpoint requires TWO
  * threaded params at once: the PARENT group's own `id` (a field that lives
@@ -1080,6 +1166,214 @@ function buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamAct
         }),
     ];
 }
+/**
+ * A grouped, nested-primary drill-down identical in shape to
+ * {@link buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamActionSteps}
+ * except the group's FIRST entry (`e1`) is sparse — it carries no `code`
+ * field at all, unlike every other entry in the group. The matched item
+ * (`e2`) does carry `code`, and the drill's literal query value equals only
+ * that item's own field, never any top-level ancestor field, so the fold
+ * plan must still structurally rebind the drill to the ancestor via a
+ * sibling ARRAY ELEMENT's `code` — but only one that actually HAS it (`e2`
+ * or `e3`), not blindly assuming the array's first element does. A fold
+ * plan whose structural search only ever inspects element `[0]` degrades to
+ * an item-bound drill here (fetching once per item instead of once per
+ * group) purely because the group's first entry happens to lack the field
+ * every other sibling carries.
+ */
+function buildMulticallNestedGroupedDrillDownSparseFirstElementAncestorScopedParamActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "group-sec1",
+                        entries: [
+                            { entryId: "e1", name: "Widget" },
+                            { entryId: "e2", code: "e2-code", name: "Gadget" },
+                            { entryId: "e3", code: "e3-code", name: "Doohickey" },
+                        ],
+                    },
+                    {
+                        masterCode: "group-sec2",
+                        entries: [
+                            { entryId: "e4", name: "Thingamajig" },
+                            { entryId: "e5", code: "e5-code", name: "Contraption" },
+                            { entryId: "e6", code: "e6-code", name: "Gizmo" },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-04-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=e2-code`,
+            requestPostData: null,
+            responseBody: {
+                details: [
+                    { entryId: "e1", description: "A widget." },
+                    { entryId: "e2", description: "A gadget." },
+                    { entryId: "e3", description: "A doohickey." },
+                ],
+            },
+            timestamp: "2025-04-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=zzz-unrelated`,
+            requestPostData: null,
+            responseBody: {
+                details: [{ entryId: "zzz-unrelated", description: "An unrelated entry." }],
+            },
+            timestamp: "2025-04-01T00:00:02Z",
+        }),
+    ];
+}
+/**
+ * A grouped, nested-primary drill-down whose drilled endpoint's TWO literal
+ * query values (`code`, `zone`) each equal BOTH the matched (first) item's
+ * own top-level fields AND the ancestor group's own structurally-
+ * corresponding fields, which themselves live inside a NESTED ancestor
+ * array (`tags.0.code` / `tags.0.zone`) rather than directly on the
+ * ancestor object — unlike
+ * {@link buildMulticallNestedGroupedDrillDownTwoLevelNestedAncestorFieldActionSteps}'s
+ * ancestor-ONLY nested field (absent from the item scope entirely), here
+ * the SAME field names and values are genuinely present on both scopes at
+ * once, for two independently-resolved params. A literal-value search over
+ * the captured request necessarily lands on the item's own field first
+ * (it's the shallower, directly-typed match), so this is the exact shape
+ * that requires {@link findStructurallyCorrespondingAncestorField}'s
+ * traversal into the ancestor's own nested array — independently, for each
+ * param — to correctly REBIND the rendered accessor onto the ancestor's
+ * structural counterpart. A fold plan that skips or fails that rebind for
+ * either param will emit an accessor reading off the item loop's own bound
+ * variable at a splice point where it is not yet declared.
+ *
+ * Every OTHER item in the same group carries its own `code`/`zone`
+ * diverging from the matched item's, and the drill's response still
+ * resolves onto every one of them, proving the drilled value is genuinely
+ * ancestor-scoped — not merely coincident with the matched item's own
+ * field — so a correct fold plan hoists the chain fetch above the item loop
+ * and fetches once per group, never once per item.
+ */
+function buildMulticallNestedGroupedDrillDownAncestorItemValueCoincidenceActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "group-sec1",
+                        tags: [{ code: "meta-code-1", zone: "west" }],
+                        entries: [
+                            { entryId: "e1", code: "meta-code-1", zone: "west", name: "Widget" },
+                            { entryId: "e2", code: "e2-own-code", zone: "e2-own-zone", name: "Gadget" },
+                        ],
+                    },
+                    {
+                        masterCode: "group-sec2",
+                        tags: [{ code: "meta-code-2", zone: "east" }],
+                        entries: [
+                            { entryId: "e3", code: "meta-code-2", zone: "east", name: "Thingamajig" },
+                            { entryId: "e4", code: "e4-own-code", zone: "e4-own-zone", name: "Contraption" },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-06-15T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=meta-code-1&zone=west`,
+            requestPostData: null,
+            responseBody: {
+                details: [
+                    { entryId: "e1", description: "A widget." },
+                    { entryId: "e2", description: "A gadget." },
+                ],
+            },
+            timestamp: "2025-06-15T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=zzz-unrelated&zone=zzz-zone`,
+            requestPostData: null,
+            responseBody: {
+                details: [{ entryId: "zzz-unrelated", description: "An unrelated entry." }],
+            },
+            timestamp: "2025-06-15T00:00:02Z",
+        }),
+    ];
+}
+/**
+ * A grouped, nested-primary drill-down whose drilled endpoint's literal
+ * query value equals ONLY the matched (first) item's own field (`ownCode`)
+ * — never the ancestor's own field directly — but the ancestor's structural
+ * counterpart lives TWO levels deep (`meta.summary.code`), generalizing
+ * {@link buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamActionSteps}'s
+ * single-level ancestor nesting to a two-level one. This is the exact
+ * structural shape from the 1.12.52 report (a `g0`-only ancestor group loop
+ * whose hoisted chain fetch reads a nested field off the ancestor's own
+ * object, with no separate item sub-loop wrapping the hoisted call itself)
+ * — the report substituted a totally unrelated, undeclared `item`
+ * identifier for the correct `g0.meta.summary.code` ancestor accessor.
+ *
+ * Every OTHER item in the same group carries its own `ownCode` diverging
+ * from the matched item's, and the drill's response still resolves onto
+ * every one of them, proving the drilled value is genuinely ancestor-scoped
+ * — not merely coincident with the matched item's own field — so a correct
+ * fold plan hoists the chain fetch above the item loop and fetches once per
+ * group, never once per item, and never references the item loop's own
+ * bound variable.
+ */
+function buildMulticallNestedGroupedDrillDownTwoLevelNestedAncestorFieldActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "group-sec1",
+                        meta: { summary: { code: "meta-code-1" } },
+                        entries: [
+                            { entryId: "e1", ownCode: "meta-code-1", name: "Widget" },
+                            { entryId: "e2", ownCode: "e2-own-code", name: "Gadget" },
+                        ],
+                    },
+                    {
+                        masterCode: "group-sec2",
+                        meta: { summary: { code: "meta-code-2" } },
+                        entries: [
+                            { entryId: "e3", ownCode: "meta-code-2", name: "Thingamajig" },
+                            { entryId: "e4", ownCode: "e4-own-code", name: "Contraption" },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-05-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=meta-code-1`,
+            requestPostData: null,
+            responseBody: {
+                details: [
+                    { entryId: "e1", description: "A widget." },
+                    { entryId: "e2", description: "A gadget." },
+                ],
+            },
+            timestamp: "2025-05-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=zzz-unrelated`,
+            requestPostData: null,
+            responseBody: {
+                details: [{ entryId: "zzz-unrelated", description: "An unrelated entry." }],
+            },
+            timestamp: "2025-05-01T00:00:02Z",
+        }),
+    ];
+}
 /**
  * A grouped, nested-primary drill-down whose drilled endpoint's literal
  * query threads TWO params, each coincidentally equal to both a value the
@@ -1244,6 +1538,166 @@ function buildMulticallNestedGroupedDrillDownDualItemLiteralDistinctSubpathAnces
         }),
     ];
 }
+const CATALOG_ENTRY_LABELS_URL = "https://api.example.com/catalog/entries/labels";
+/**
+ * TWO fully independent drill-down targets sharing one ancestor group,
+ * whose literal query values each equal ONLY the matched (first) entry's
+ * own `entryId` — never any distinct ancestor-level field — but whose
+ * responses each return every OTHER sibling's row in the same group too,
+ * so both targets independently prove {@link isFoldTargetAncestorScoped}
+ * and rebind through the ancestor's own nested array (mirroring
+ * {@link buildMulticallNestedGroupedDrillDownDistinctValueAncestorScopedParamActionSteps}'s
+ * single-target rebind, generalized to two independent, CO-HOISTED targets
+ * at once). Regression coverage for a fold-hoist decision that derives
+ * whether a call may hoist above the item loop from the FINAL rendered
+ * text rather than from the value/placeholder bindings that actually feed
+ * the splice: a bug there can let one target's hoist decision silently
+ * disagree with what its own accessor bindings prove, emitting a call that
+ * references the item loop's own bound variable above the loop that
+ * declares it.
+ *
+ * `r1`/`r2` are the real drills (both resolve group `sec1` via `e1`'s own
+ * `entryId`). `r3`/`r4` are decoys — same drilled pathnames, but each
+ * returns an EMPTY result set — so {@link findFrozenVaryingDrillParams}'s
+ * same-endpoint variance check has a second, genuinely differing capture to
+ * compare each target's own param against, without themselves being
+ * mistaken for an independent primary/drill pair of their own.
+ */
+function buildMulticallAncestorOnlyMultiTargetDrillDownActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "sec1",
+                        entries: [
+                            { entryId: "e1", name: "Widget" },
+                            { entryId: "e2", name: "Gadget" },
+                            { entryId: "e3", name: "Doohickey" },
+                        ],
+                    },
+                    {
+                        masterCode: "sec2",
+                        entries: [
+                            { entryId: "e4", name: "Thingamajig" },
+                            { entryId: "e5", name: "Contraption" },
+                            { entryId: "e6", name: "Gizmo" },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-08-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=e1`,
+            requestPostData: null,
+            responseBody: {
+                details: [
+                    { entryId: "e1", description: "A widget." },
+                    { entryId: "e2", description: "A gadget." },
+                    { entryId: "e3", description: "A doohickey." },
+                ],
+            },
+            timestamp: "2025-08-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: `${CATALOG_ENTRY_LABELS_URL}?tag=e1`,
+            requestPostData: null,
+            responseBody: {
+                labels: [
+                    { entryId: "e1", label: "north-widget" },
+                    { entryId: "e2", label: "north-gadget" },
+                    { entryId: "e3", label: "north-doohickey" },
+                ],
+            },
+            timestamp: "2025-08-01T00:00:02Z",
+        }),
+        buildStep("r3", {
+            url: `${CATALOG_ENTRY_DETAILS_URL}?code=zzz-unrelated`,
+            requestPostData: null,
+            responseBody: { details: [] },
+            timestamp: "2025-08-01T00:00:03Z",
+        }),
+        buildStep("r4", {
+            url: `${CATALOG_ENTRY_LABELS_URL}?tag=zzz-unrelated`,
+            requestPostData: null,
+            responseBody: { labels: [] },
+            timestamp: "2025-08-01T00:00:04Z",
+        }),
+    ];
+}
+/**
+ * An ancestor-scoped drill target generalizing
+ * {@link buildMulticallAncestorOnlyMultiTargetDrillDownActionSteps} from ONE
+ * threaded field to TWO: the drilled endpoint's query threads BOTH the
+ * primary join field (`entryId`, declared via `joinFields` and therefore
+ * always forced item-bound in {@link buildThreadedFieldPairs}'s raw input)
+ * AND a second, independently-discovered field (`regionCode`) that
+ * {@link findThreadedJoinFields} threads purely because its literal value is
+ * present in the drilled request — never declared in `joinFields` at all.
+ * `regionCode` is homogeneous across every sibling entry in a group (every
+ * entry in `sec1` shares `"north"`, every entry in `sec2` shares `"south"`),
+ * so it is genuinely ancestor-scoped data, not a per-item value — proving
+ * {@link buildThreadedFieldPairs}'s rebind must independently resolve EACH
+ * threaded field's own structural correspondence rather than deciding
+ * hoistability once for the whole target off a single post-hoc scan of the
+ * rendered text. Regression coverage for
+ * {@link https://github.com | recon-generate}'s fold-hoist ground-truth
+ * `referencesItemVar` signal (computed per value/placeholder binding, not by
+ * re-scanning final text): with two independently-rebound fields on one
+ * target, a hoist decision that silently disagrees with what either field's
+ * OWN accessor binding proves can no longer hide behind the other field's
+ * successful rebind.
+ */
+function buildMulticallAncestorScopedDualThreadedFieldDrillDownActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SECTIONS_URL,
+            requestPostData: null,
+            responseBody: {
+                sections: [
+                    {
+                        masterCode: "sec1",
+                        entries: [
+                            { entryId: "e1", regionCode: "north", name: "Widget" },
+                            { entryId: "e2", regionCode: "north", name: "Gadget" },
+                            { entryId: "e3", regionCode: "north", name: "Doohickey" },
+                        ],
+                    },
+                    {
+                        masterCode: "sec2",
+                        entries: [
+                            { entryId: "e4", regionCode: "south", name: "Thingamajig" },
+                            { entryId: "e5", regionCode: "south", name: "Contraption" },
+                            { entryId: "e6", regionCode: "south", name: "Gizmo" },
+                        ],
+                    },
+                ],
+            },
+            timestamp: "2025-09-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: `${CATALOG_ENTRY_LABELS_URL}?code=e1&region=north`,
+            requestPostData: null,
+            responseBody: {
+                labels: [
+                    { entryId: "e1", label: "north-widget" },
+                    { entryId: "e2", label: "north-gadget" },
+                    { entryId: "e3", label: "north-doohickey" },
+                ],
+            },
+            timestamp: "2025-09-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: `${CATALOG_ENTRY_LABELS_URL}?code=zzz-unrelated&region=zzz-region`,
+            requestPostData: null,
+            responseBody: { labels: [] },
+            timestamp: "2025-09-01T00:00:02Z",
+        }),
+    ];
+}
 const ACCOUNT_SEARCH_URL = "https://api.example.com/accounts/search";
 const ACCOUNT_DETAIL_URL = "https://api.example.com/accounts/detail";
 /**
@@ -2852,4 +3306,39 @@ function buildSessionHeartbeatNoiseStep(timestamp) {
         timestamp,
     });
 }
+const ORDERS_LINE_ITEMS_URL = "https://api.example.com/orders/line-items";
+const ORDERS_PROMO_URL = "https://api.example.com/orders/promo-eligibility";
+/**
+ * A flat, non-ancestor single-shot search → per-item drill-down whose primary
+ * array (`lineItems[]`) has no nested wildcard crossing at all, so its fold
+ * loop variable renders as bare `item`, never `g<n>` — structurally unrelated
+ * to any ancestor-grouped fold plan. Exists solely to be emitted as a SEPARATE
+ * `emitMultiStepExecuteHttp` call (its own generated function) and
+ * concatenated after an ancestor-grouped fold's own output, so a test can
+ * assert that this function's own, legitimately-declared `item` binding never
+ * bleeds into an unrelated, EARLIER ancestor (`g0`)-scoped hoisted call
+ * elsewhere in the same generated file — the two functions share no runtime
+ * scope, only file-level adjacency.
+ */
+function buildMulticallOrdersLineItemPromoEligibilityActionSteps() {
+    return [
+        buildStep("r0", {
+            url: ORDERS_LINE_ITEMS_URL,
+            requestPostData: '{"orderId":"ord-1"}',
+            responseBody: {
+                lineItems: [
+                    { sku: "sku-a", quantity: 2 },
+                    { sku: "sku-b", quantity: 1 },
+                ],
+            },
+            timestamp: "2025-06-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: ORDERS_PROMO_URL,
+            requestPostData: '{"sku":"sku-a"}',
+            responseBody: { eligibility: [{ sku: "sku-a", eligible: true }] },
+            timestamp: "2025-06-01T00:00:01Z",
+        }),
+    ];
+}
 //# sourceMappingURL=recon-generate-multicall-fixture.js.map