@enricai/barnacle 1.12.20 → 1.12.21

package/dist/scripts/recon-generate-multicall-fixture.d.ts

@@ -17,6 +17,8 @@ export declare function buildCapture(overrides: {
     responseBody: unknown;
     timestamp: string;
     requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    method?: string;
 }): Capture;
 export declare function buildStep(varName: string, overrides: {
     url: string;
@@ -24,6 +26,8 @@ export declare function buildStep(varName: string, overrides: {
     responseBody: unknown;
     timestamp: string;
     requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    method?: string;
 }): MulticallFixtureStep;
 /**
  * Reproduces a listings-fixture G1/G2 recon capture set: a
@@ -399,6 +403,30 @@ export declare function buildMulticallSingleShotSearchDrillDownChainedDependentM
  * chain's TERMINAL (history) response, not the drill step's own `prices[]`.
  */
 export declare function buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps(): MulticallFixtureStep[];
+/**
+ * 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`.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownHeaderMintedChainedResponseValueActionSteps(): MulticallFixtureStep[];
+/**
+ * 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`.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownBooleanChainedResponseValueActionSteps(): MulticallFixtureStep[];
 /**
  * A nested-join-key sibling of {@link buildMulticallSingleShotSearchDrillDownChainedDependentActionSteps}:
  * each primary `results[]` item carries its join key under a nested
@@ -538,6 +566,39 @@ export declare function buildMulticallSingleShotSearchDrillDownArrayWrappedChain
  * reproduces identically whether or not the terminal body is array-wrapped.
  */
 export declare function buildMulticallSingleShotSearchDrillDownArrayWrappedNumericChainedJoinFieldActionSteps(): MulticallFixtureStep[];
+/**
+ * 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.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownShortNumericChainedJoinFieldActionSteps(): MulticallFixtureStep[];
+/**
+ * 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.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownShortCookieChainedJoinFieldActionSteps(): MulticallFixtureStep[];
 /**
  * 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
@@ -564,4 +625,72 @@ export declare function buildMulticallSingleShotSearchDrillDownArrayWrappedImmed
  * for the fold-loop's later per-item `parameterize` pass.
  */
 export declare function buildMulticallSingleShotSearchDrillDownArrayWrappedNumericImmediateJoinFieldActionSteps(): MulticallFixtureStep[];
+/**
+ * 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.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownArrayWrappedBooleanImmediateJoinFieldActionSteps(): MulticallFixtureStep[];
+/**
+ * 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`.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownHeaderThreadedJoinChainedDependentActionSteps(): MulticallFixtureStep[];
+/**
+ * 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.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownGetEntryHopChainedDependentActionSteps(): MulticallFixtureStep[];
+/**
+ * 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.
+ */
+export declare function buildMulticallSingleShotSearchDrillDownResponseHeaderThreadedJoinChainedDependentActionSteps(): MulticallFixtureStep[];
 //# sourceMappingURL=recon-generate-multicall-fixture.d.ts.map

package/dist/scripts/recon-generate-multicall-fixture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recon-generate-multicall-fixture.d.ts","sourceRoot":"","sources":["../../src/scripts/recon-generate-multicall-fixture.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recon-generate-multicall-fixture.d.ts","sourceRoot":"","sources":["../../src/scripts/recon-generate-multicall-fixture.ts"],"names":[],"mappings":"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"}

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

@@ -32,6 +32,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 +43,24 @@ 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;
 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 +1110,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 +1591,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 +1755,185 @@ 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",
+        }),
+    ];
+}
 //# sourceMappingURL=recon-generate-multicall-fixture.js.map