@enricai/barnacle 1.12.20 → 1.12.22

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOLD_RETURN_WILDCARD_SCALABLE_SPEC = exports.FOLD_RETURN_SCALABLE_SPEC = void 0;
 exports.buildCapture = buildCapture;
 exports.buildStep = buildStep;
 exports.buildMulticallHeterogeneousActionSteps = buildMulticallHeterogeneousActionSteps;
@@ -32,6 +33,8 @@ exports.buildMulticallSingleShotSearchDrillDownMultiMatchActionSteps = buildMult
 exports.buildMulticallSingleShotSearchDrillDownTypeMismatchJoinActionSteps = buildMulticallSingleShotSearchDrillDownTypeMismatchJoinActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownChainedDependentMultipartChainStepActionSteps = buildMulticallSingleShotSearchDrillDownChainedDependentMultipartChainStepActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownHeaderMintedChainedResponseValueActionSteps = buildMulticallSingleShotSearchDrillDownHeaderMintedChainedResponseValueActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownBooleanChainedResponseValueActionSteps = buildMulticallSingleShotSearchDrillDownBooleanChainedResponseValueActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownNestedJoinFieldChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownNestedJoinFieldChainedDependentActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownRequeriedPrimaryOverlapActionSteps = buildMulticallSingleShotSearchDrillDownRequeriedPrimaryOverlapActionSteps;
 exports.buildMulticallSingleShotSearchTwoIndependentArraysActionSteps = buildMulticallSingleShotSearchTwoIndependentArraysActionSteps;
@@ -41,18 +44,27 @@ exports.buildMulticallSingleShotSearchDrillDownOpaqueIntermediateChainedDependen
 exports.buildMulticallSingleShotSearchDrillDownRichnessTiedConfirmationHopChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownRichnessTiedConfirmationHopChainedDependentActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownArrayWrappedChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownArrayWrappedChainedDependentActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownArrayWrappedNumericChainedJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownArrayWrappedNumericChainedJoinFieldActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownShortNumericChainedJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownShortNumericChainedJoinFieldActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownShortCookieChainedJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownShortCookieChainedJoinFieldActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownArrayWrappedImmediateJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownArrayWrappedImmediateJoinFieldActionSteps;
 exports.buildMulticallSingleShotSearchDrillDownArrayWrappedNumericImmediateJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownArrayWrappedNumericImmediateJoinFieldActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownArrayWrappedBooleanImmediateJoinFieldActionSteps = buildMulticallSingleShotSearchDrillDownArrayWrappedBooleanImmediateJoinFieldActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownHeaderThreadedJoinChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownHeaderThreadedJoinChainedDependentActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownGetEntryHopChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownGetEntryHopChainedDependentActionSteps;
+exports.buildMulticallSingleShotSearchDrillDownResponseHeaderThreadedJoinChainedDependentActionSteps = buildMulticallSingleShotSearchDrillDownResponseHeaderThreadedJoinChainedDependentActionSteps;
+exports.buildFoldReturnScalableActionSequence = buildFoldReturnScalableActionSequence;
+exports.buildFoldReturnWildcardScalableActionSequence = buildFoldReturnWildcardScalableActionSequence;
+const date_fns_1 = require("date-fns");
 function buildCapture(overrides) {
     return {
         timestamp: overrides.timestamp,
         phase: "action",
-        method: "POST",
+        method: overrides.method ?? "POST",
         url: overrides.url,
         status: 200,
         requestHeaders: overrides.requestHeaders ?? { "Content-Type": "application/json" },
         requestPostData: overrides.requestPostData,
-        responseHeaders: { "content-type": "application/json" },
+        responseHeaders: overrides.responseHeaders ?? { "content-type": "application/json" },
         responseBody: overrides.responseBody,
         operationName: null,
         query: null,
@@ -1102,6 +1114,84 @@ function buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps() {
         }),
     ];
 }
+/**
+ * A response-header sibling of {@link buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps}:
+ * the drill step's (`r1`) response mints its join token (`tok-a1`) ONLY in a
+ * custom response HEADER (`X-Price-Token`) — its body is empty, unlike the
+ * sibling's `priceToken` body field. A third step (`r2`) threads that header
+ * value into its own request body and carries the real per-item `history[]`
+ * array. `computeFoldChain`'s `dependsOnChain` check must walk `r1`'s
+ * response headers (not just its body) to see the shared value, extending
+ * the chain to `[drillStepIndex, historyStepIndex]` rather than stopping at
+ * `r1`.
+ */
+function buildMulticallSingleShotSearchDrillDownHeaderMintedChainedResponseValueActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ sku: "sku-a" }, { sku: "sku-b" }],
+            },
+            timestamp: "2024-11-16T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_PRICING_URL,
+            requestPostData: '{"sku":"sku-a"}',
+            responseBody: {},
+            responseHeaders: { "content-type": "application/json", "X-Price-Token": "tok-a1" },
+            timestamp: "2024-11-16T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: CATALOG_PRICE_HISTORY_URL,
+            requestPostData: '{"priceToken":"tok-a1"}',
+            responseBody: {
+                history: [{ sku: "sku-a", amount: 18.5, asOf: "2024-11-01" }],
+            },
+            timestamp: "2024-11-16T00:00:02Z",
+        }),
+    ];
+}
+const CATALOG_VERIFICATION_STATUS_URL = "https://api.example.com/catalog/verification-status";
+/**
+ * A boolean-threading sibling of {@link buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps}:
+ * the drill step's (`r1`) response mints ONLY a boolean value
+ * (`{ verified: true }`) and carries no array of its own — unlike the
+ * `priceToken`/`prices[]` sibling, this drill step is NOT foldable in
+ * isolation. A third step (`r2`) threads that boolean (rendered as the
+ * string `"true"`) into its request and carries the real per-item
+ * `history[]` array in its response. `computeFoldChain` must recognize the
+ * boolean leaf as a genuine chain-dependency source and extend the chain to
+ * `[drillStepIndex, historyStepIndex]` rather than stopping at `r1`.
+ */
+function buildMulticallSingleShotSearchDrillDownBooleanChainedResponseValueActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ sku: "sku-a" }, { sku: "sku-b" }],
+            },
+            timestamp: "2024-12-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_PRICING_URL,
+            requestPostData: '{"sku":"sku-a"}',
+            responseBody: {
+                verified: true,
+            },
+            timestamp: "2024-12-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: CATALOG_VERIFICATION_STATUS_URL,
+            requestPostData: '{"verified":"true"}',
+            responseBody: {
+                history: [{ sku: "sku-a", amount: 18.5, asOf: "2024-11-01" }],
+            },
+            timestamp: "2024-12-01T00:00:02Z",
+        }),
+    ];
+}
 /**
  * A nested-join-key sibling of {@link buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps}:
  * each primary `results[]` item carries its join key under a nested
@@ -1505,6 +1595,90 @@ function buildMulticallSingleShotSearchDrillDownArrayWrappedNumericChainedJoinFi
         }),
     ];
 }
+/**
+ * A sibling of
+ * {@link buildMulticallSingleShotSearchDrillDownArrayWrappedNumericChainedJoinFieldActionSteps}
+ * isolating a DIFFERENT gap in the numeric chain-produced join field family:
+ * `r1`'s produced token is a bare (non-array-wrapped) JSON number, and — the
+ * shape that matters here — it is SHORT (`42`/`43`, two digits) rather than
+ * an 8-digit token. `indexStateValues` gates every candidate state value on
+ * `MIN_STATE_VALUE_LENGTH` (8 chars), a threshold sized to keep an unrelated
+ * short STRING (an enum code, a page number) from colliding with arbitrary
+ * substrings elsewhere; applied uniformly to a bare NUMBER's stringified
+ * length, it also silently excludes a short numeric id/token — exactly the
+ * common shape for an order/account/status id — from ever being indexed as
+ * producible state. Without that index entry, `compileActionSteps` never
+ * emits a `produces[]` accessor for `r1`'s response, so `r2`'s templated
+ * body has nothing to substitute and falls back to treating `{"token":...}`
+ * as an opaque caller-supplied payload field (`payload.token`) instead of
+ * the per-item threaded value — every iteration would send whatever (or
+ * nothing) the caller passed, not each primary item's own token.
+ */
+function buildMulticallSingleShotSearchDrillDownShortNumericChainedJoinFieldActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ orderId: "order-a" }, { orderId: "order-b" }],
+            },
+            timestamp: "2024-10-04T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_ORDER_STATUS_URL,
+            requestPostData: '{"orderId":"order-a"}',
+            responseBody: [42],
+            timestamp: "2024-10-04T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: ORDER_HISTORY_URL,
+            requestPostData: '{"token":42}',
+            responseBody: {
+                entries: [{ token: 42, ts: "2024-10-04T00:00:02Z", event: "shipped" }],
+            },
+            timestamp: "2024-10-04T00:00:02Z",
+        }),
+    ];
+}
+/**
+ * Cookie-origin sibling of
+ * {@link buildMulticallSingleShotSearchDrillDownShortNumericChainedJoinFieldActionSteps}:
+ * here `r1` mints the short chain-produced token (`tok1`, under
+ * `MIN_STATE_VALUE_LENGTH`) via `Set-Cookie` rather than the response body,
+ * AND echoes the same value in its response body (the "body-level echo" that
+ * lets {@link collectDependentDrillDownChainValues} confirm the cookie value
+ * is chain-produced, exactly as a body-sourced token would be). `r2` threads
+ * `tok1` back via its request body. Exercises `indexStateValues`' Set-Cookie
+ * branch's `chainForceIncludeValues`/`forceIncludeValues` exemption, mirroring
+ * the body-value floor exemption.
+ */
+function buildMulticallSingleShotSearchDrillDownShortCookieChainedJoinFieldActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ orderId: "order-a" }, { orderId: "order-b" }],
+            },
+            timestamp: "2024-10-05T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_ORDER_STATUS_URL,
+            requestPostData: '{"orderId":"order-a"}',
+            responseHeaders: { "set-cookie": "sess=tok1; Path=/; HttpOnly" },
+            responseBody: { echoedToken: "tok1" },
+            timestamp: "2024-10-05T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: ORDER_HISTORY_URL,
+            requestPostData: '{"token":"tok1"}',
+            responseBody: {
+                entries: [{ token: "tok1", ts: "2024-10-05T00:00:02Z", event: "shipped" }],
+            },
+            timestamp: "2024-10-05T00:00:02Z",
+        }),
+    ];
+}
 /**
  * A different sibling of the same array-wrapped-join-field failure family:
  * here it's the IMMEDIATE drill step (`r1`), not a later chain hop, whose
@@ -1585,4 +1759,331 @@ function buildMulticallSingleShotSearchDrillDownArrayWrappedNumericImmediateJoin
         }),
     ];
 }
+/**
+ * Same array-wrapped-immediate-join-field shape as
+ * {@link buildMulticallSingleShotSearchDrillDownArrayWrappedNumericImmediateJoinFieldActionSteps},
+ * but the primary item's join field is a bare JSON BOOLEAN (`flag: true`)
+ * rather than a number or string. `walkStringLeaves` (used by the spare
+ * check in `applyStructuredValuePayloadSubstitutions`) silently skips
+ * boolean leaves the same way it skips number leaves, so a boolean join
+ * value wrapped in `{"flags":[true]}` was frozen into an opaque
+ * `${JSON.stringify(payload.flags)}` blob instead of being spared for the
+ * fold-loop's later per-item `parameterize` pass.
+ */
+function buildMulticallSingleShotSearchDrillDownArrayWrappedBooleanImmediateJoinFieldActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ flag: true }, { flag: false }],
+            },
+            timestamp: "2024-10-03T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_ORDER_STATUS_URL,
+            requestPostData: '{"flags":[true]}',
+            responseBody: ["status-token-true"],
+            timestamp: "2024-10-03T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: ORDER_HISTORY_BULK_URL,
+            requestPostData: '{"tokens":["status-token-true"]}',
+            responseBody: {
+                entries: [
+                    { statusToken: "status-token-true", ts: "2024-10-03T00:00:02Z", event: "shipped" },
+                ],
+            },
+            timestamp: "2024-10-03T00:00:02Z",
+        }),
+    ];
+}
+const ACCOUNT_STATUS_URL = "https://api.example.com/accounts/status";
+const ACCOUNT_TRANSACTIONS_URL = "https://api.example.com/accounts/transactions";
+/**
+ * A dependent (chained) drill-down whose join key is threaded ONLY through a
+ * request HEADER (`API-Token`) on the chain's ENTRY hop (`r1`) — invisible to
+ * `detectDrillDownFoldPlan`'s structural heuristic exactly like
+ * {@link buildMulticallSingleShotSearchDrillDownHeaderThreadedJoinActionSteps}
+ * — so only a flow-declared `foldReturn` can resolve this fold at all. Unlike
+ * every existing header-threaded-join fixture, though, a site author writing
+ * that `foldReturn` naturally points `endpointPattern` at `r2`
+ * (`/accounts/transactions`) — the call whose OWN response actually carries
+ * the per-item data (`transactions[]`) they want folded — not at `r1`
+ * (`/accounts/status`), the opaque intermediate hop that merely carries the
+ * `accountId`→`API-Token` header thread onward as a `statusToken`. `r2`'s own
+ * request only ever carries that threaded `statusToken`, never `accountId`
+ * in any form (body, URL, or header) — the join key is resolvable only by
+ * walking back to `r1`, exactly the way `computeFoldChain` already walks
+ * FORWARD from a resolved entry hop to a richer terminal. `resultsPath`
+ * anchors on `accounts`, `joinFields` on `accountId`.
+ */
+function buildMulticallSingleShotSearchDrillDownHeaderThreadedJoinChainedDependentActionSteps() {
+    return [
+        buildStep("r0", {
+            url: ACCOUNT_SEARCH_URL,
+            requestPostData: JSON.stringify({ page: 1 }),
+            responseBody: {
+                accounts: [
+                    { accountId: 42, name: "Acme" },
+                    { accountId: 43, name: "Globex" },
+                ],
+            },
+            timestamp: "2024-08-01T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: ACCOUNT_STATUS_URL,
+            requestPostData: null,
+            requestHeaders: { "Content-Type": "application/json", "API-Token": "42" },
+            responseBody: { statusToken: "status-token-42" },
+            timestamp: "2024-08-01T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: ACCOUNT_TRANSACTIONS_URL,
+            requestPostData: JSON.stringify({ statusToken: "status-token-42" }),
+            responseBody: {
+                transactions: [{ statusToken: "status-token-42", transactionId: "t-42", amount: 19.99 }],
+            },
+            timestamp: "2024-08-01T00:00:02Z",
+        }),
+    ];
+}
+const ORDER_STATUS_LOOKUP_URL = "https://api.example.com/orders/status-lookup";
+const ORDER_EVENTS_URL = "https://api.example.com/orders/events";
+/**
+ * A dependent (chained) drill-down whose ENTRY hop (`r1`) is a `GET`
+ * request — not the `POST` every other chained-dependent fixture in this
+ * file uses — and whose response produces the chain's join value
+ * (`statusToken`) as a non-UUID string. `indexStateValues` indexes a `GET`
+ * capture's response leaves ONLY when they are UUID-shaped
+ * (`isGet && !UUID_REGEX.test(value)` skips everything else, a filter aimed
+ * at excluding noisy short non-UUID strings a GET-only telemetry/schema
+ * fetch surfaces); that filter runs unconditionally, with no exemption for a
+ * value `collectDependentDrillDownChainValues` has already confirmed is
+ * threaded from this exact hop into a later chain hop's own request — unlike
+ * the `MIN_STATE_VALUE_LENGTH` floor a few lines above it, which DOES carry
+ * that exemption. So a chain-produced token minted by a GET response is
+ * never indexed as producible state at all, `compileActionSteps` never
+ * emits a `produces[]` accessor for it, and `r2`'s templated body has
+ * nothing to substitute — every iteration renders the literal string
+ * `"undefined"` instead of threading each primary item's own token.
+ */
+function buildMulticallSingleShotSearchDrillDownGetEntryHopChainedDependentActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ orderId: "order-a" }, { orderId: "order-b" }],
+            },
+            timestamp: "2024-10-05T00:00:00Z",
+        }),
+        buildStep("r1", {
+            method: "GET",
+            url: `${ORDER_STATUS_LOOKUP_URL}?orderId=order-a`,
+            requestPostData: null,
+            responseBody: { statusToken: "status-token-order-a" },
+            timestamp: "2024-10-05T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: ORDER_EVENTS_URL,
+            requestPostData: '{"token":"status-token-order-a"}',
+            responseBody: {
+                entries: [{ token: "status-token-order-a", ts: "2024-10-05T00:00:02Z", event: "shipped" }],
+            },
+            timestamp: "2024-10-05T00:00:02Z",
+        }),
+    ];
+}
+/**
+ * A response-header sibling of {@link buildMulticallSingleShotSearchDrillDownGetEntryHopChainedDependentActionSteps}:
+ * the chain's drill hop (`r1`) mints its join token (`tok-a1`) ONLY in a
+ * custom response HEADER (`X-Price-Token`) — its body is empty ({}), unlike
+ * {@link buildMulticallSingleShotSearchDrillDownHeaderMintedChainedResponseValueActionSteps}'s
+ * body-echo-free sibling, which threads the header value forward via the
+ * request BODY. Here the terminal hop (`r2`) instead threads that value back
+ * as a REQUEST HEADER of its own (also named `X-Price-Token`) — the only
+ * shape `createHttpClient`'s `bind` option can actually thread a
+ * header-origin value into, since the emitted response variable never
+ * exposes response headers to the rest of the generated code. Exercises
+ * `compileActionSteps`' non-cookie response-header produce block: without it,
+ * `tok-a1` is never captured into a `produces[]`/`bind` entry at all, and
+ * `r2`'s per-item call goes out with no `X-Price-Token` header, so the
+ * terminal `history[]` fold silently collapses to whichever primary item the
+ * stub happens to answer first instead of each item's own token.
+ */
+function buildMulticallSingleShotSearchDrillDownResponseHeaderThreadedJoinChainedDependentActionSteps() {
+    return [
+        buildStep("r0", {
+            url: CATALOG_SEARCH_URL,
+            requestPostData: '{"page":1}',
+            responseBody: {
+                results: [{ sku: "sku-a" }, { sku: "sku-b" }],
+            },
+            timestamp: "2024-12-10T00:00:00Z",
+        }),
+        buildStep("r1", {
+            url: CATALOG_PRICING_URL,
+            requestPostData: '{"sku":"sku-a"}',
+            responseBody: {},
+            responseHeaders: { "content-type": "application/json", "X-Price-Token": "tok-a1" },
+            timestamp: "2024-12-10T00:00:01Z",
+        }),
+        buildStep("r2", {
+            url: CATALOG_PRICE_HISTORY_URL,
+            requestPostData: "{}",
+            requestHeaders: { "Content-Type": "application/json", "X-Price-Token": "tok-a1" },
+            responseBody: {
+                history: [{ sku: "sku-a", amount: 18.5, asOf: "2024-11-01" }],
+            },
+            timestamp: "2024-12-10T00:00:02Z",
+        }),
+    ];
+}
+/**
+ * The declared `foldReturn` matching {@link buildFoldReturnScalableActionSequence}'s
+ * lone real primary/drill-down pair. The join value is threaded only through
+ * a request HEADER (never the URL or body), mirroring the header-threaded
+ * fixtures used elsewhere in this module — `detectDrillDownFoldPlan`'s
+ * structural heuristic never scans headers, so resolving this pair is only
+ * reachable through `buildFoldPlanFromSpec`, the exact code path the
+ * incident's large-capture-set hang was traced to.
+ */
+exports.FOLD_RETURN_SCALABLE_SPEC = {
+    endpointPattern: "/catalog/pricing/",
+    resultsPath: "results",
+    joinFields: ["sku"],
+};
+const FOLD_RETURN_SCALABLE_BASE_TIMESTAMP = new Date("2024-11-01T00:00:00.000Z");
+/**
+ * Generates `n` {@link MulticallFixtureStep} entries reproducing the reported
+ * incident's shape at any scale: a large capture set dominated by noise
+ * candidates, with exactly one primary/drill-down pair that actually
+ * satisfies {@link FOLD_RETURN_SCALABLE_SPEC}. The real primary is placed
+ * first and the real drill-down last, so every noise step sits between them
+ * and `buildFoldPlanFromSpec`'s primary×drill scan has to walk the full
+ * candidate set to find the one true match — the same "one eligible pair
+ * buried among many candidates" shape the incident's 2000+-capture run hit.
+ *
+ * Noise steps alternate between two shapes that are each independently
+ * eligible for one side of the scan without ever completing a match:
+ * - a "noise primary" re-hitting the same search endpoint with its own
+ *   unique `sku`, so `objectItemsAtPath` treats it as a valid primary
+ *   candidate at every even noise slot;
+ * - a "noise drill" re-hitting the same pricing endpoint (so it passes
+ *   `compileFoldReturnEndpointMatcher`) with its own unique, non-matching
+ *   `X-Item-Sku` header, so every real primary/noise-drill and noise-
+ *   primary/real-drill combination is scanned and rejected.
+ *
+ * Since no noise step's join value ever matches another step's, none of
+ * them can complete a fold — `resolveFoldPlan` still returns exactly the one
+ * plan for the real pair, regardless of how large `n` is.
+ */
+function buildFoldReturnScalableActionSequence(n) {
+    if (n < 2)
+        throw new Error(`buildFoldReturnScalableActionSequence requires n >= 2, got ${n}`);
+    const timestampAt = (index) => (0, date_fns_1.addSeconds)(FOLD_RETURN_SCALABLE_BASE_TIMESTAMP, index).toISOString();
+    const realPrimary = buildStep("primary", {
+        url: CATALOG_SEARCH_URL,
+        requestPostData: '{"page":1}',
+        responseBody: { results: [{ sku: "sku-real" }] },
+        timestamp: timestampAt(0),
+    });
+    const realDrill = buildStep("drill", {
+        url: CATALOG_PRICING_URL,
+        requestPostData: '{"lookup":true}',
+        responseBody: { prices: [{ sku: "sku-real", amount: 19.99 }] },
+        timestamp: timestampAt(n - 1),
+        requestHeaders: { "Content-Type": "application/json", "X-Item-Sku": "sku-real" },
+    });
+    const noiseSteps = Array.from({ length: n - 2 }, (_, i) => {
+        const index = i + 1;
+        return i % 2 === 0
+            ? buildStep(`noise-primary-${i}`, {
+                url: CATALOG_SEARCH_URL,
+                requestPostData: `{"page":${index + 1}}`,
+                responseBody: { results: [{ sku: `sku-noise-primary-${i}` }] },
+                timestamp: timestampAt(index),
+            })
+            : buildStep(`noise-drill-${i}`, {
+                url: CATALOG_PRICING_URL,
+                requestPostData: '{"lookup":true}',
+                responseBody: { prices: [{ sku: `sku-noise-drill-${i}`, amount: 9.99 }] },
+                timestamp: timestampAt(index),
+                requestHeaders: {
+                    "Content-Type": "application/json",
+                    "X-Item-Sku": `sku-noise-drill-${i}`,
+                },
+            });
+    });
+    return [realPrimary, ...noiseSteps, realDrill];
+}
+/**
+ * A wildcard-`resultsPath` sibling of {@link FOLD_RETURN_SCALABLE_SPEC}: the
+ * primary item lives under a single nested array-of-objects hop
+ * (`groups.*.items`) rather than a flat top-level array, exercising
+ * {@link objectItemsAtPath}'s `ARRAY_WILDCARD_SEGMENT` flatMap branch instead
+ * of its flat-path branch. Pairs with
+ * {@link buildFoldReturnWildcardScalableActionSequence}, which reproduces the
+ * same "one real pair buried among many candidates" shape as
+ * {@link buildFoldReturnScalableActionSequence} but with every primary's
+ * items nested one `groups[]` level deep.
+ */
+exports.FOLD_RETURN_WILDCARD_SCALABLE_SPEC = {
+    endpointPattern: "/catalog/pricing/",
+    resultsPath: "groups.*.items",
+    joinFields: ["sku"],
+};
+/**
+ * Wildcard-`resultsPath` sibling of {@link buildFoldReturnScalableActionSequence}:
+ * identical noise/real-pair shape and scale, except every primary response
+ * (real and noise alike) nests its item under a single-element `groups[]`
+ * array (`{ groups: [ { items: [...] } ] }`) instead of a flat top-level
+ * array, so `objectItemsAtPath` must resolve {@link
+ * FOLD_RETURN_WILDCARD_SCALABLE_SPEC}'s `groups.*.items` wildcard path
+ * across the full candidate set rather than a flat `resultsPath`. Proves the
+ * value-indexed pruning `buildFoldPlanFromSpec` relies on (keyed on join
+ * VALUES, not on `resultsPath` shape) stays linear at scale under the
+ * wildcard branch too.
+ */
+function buildFoldReturnWildcardScalableActionSequence(n) {
+    if (n < 2) {
+        throw new Error(`buildFoldReturnWildcardScalableActionSequence requires n >= 2, got ${n}`);
+    }
+    const timestampAt = (index) => (0, date_fns_1.addSeconds)(FOLD_RETURN_SCALABLE_BASE_TIMESTAMP, index).toISOString();
+    const realPrimary = buildStep("primary", {
+        url: CATALOG_SEARCH_URL,
+        requestPostData: '{"page":1}',
+        responseBody: { groups: [{ items: [{ sku: "sku-real" }] }] },
+        timestamp: timestampAt(0),
+    });
+    const realDrill = buildStep("drill", {
+        url: CATALOG_PRICING_URL,
+        requestPostData: '{"lookup":true}',
+        responseBody: { prices: [{ sku: "sku-real", amount: 19.99 }] },
+        timestamp: timestampAt(n - 1),
+        requestHeaders: { "Content-Type": "application/json", "X-Item-Sku": "sku-real" },
+    });
+    const noiseSteps = Array.from({ length: n - 2 }, (_, i) => {
+        const index = i + 1;
+        return i % 2 === 0
+            ? buildStep(`noise-primary-${i}`, {
+                url: CATALOG_SEARCH_URL,
+                requestPostData: `{"page":${index + 1}}`,
+                responseBody: { groups: [{ items: [{ sku: `sku-noise-primary-${i}` }] }] },
+                timestamp: timestampAt(index),
+            })
+            : buildStep(`noise-drill-${i}`, {
+                url: CATALOG_PRICING_URL,
+                requestPostData: '{"lookup":true}',
+                responseBody: { prices: [{ sku: `sku-noise-drill-${i}`, amount: 9.99 }] },
+                timestamp: timestampAt(index),
+                requestHeaders: {
+                    "Content-Type": "application/json",
+                    "X-Item-Sku": `sku-noise-drill-${i}`,
+                },
+            });
+    });
+    return [realPrimary, ...noiseSteps, realDrill];
+}
 //# sourceMappingURL=recon-generate-multicall-fixture.js.map