@enricai/barnacle 1.12.17 → 1.12.19

package/dist/scripts/recon-generate.js

@@ -33,6 +33,7 @@ exports.selectPayloadAction = selectPayloadAction;
 exports.selectReturnAction = selectReturnAction;
 exports.selectEffectiveResponseBody = selectEffectiveResponseBody;
 exports.extractEntryUrlParams = extractEntryUrlParams;
+exports.gatherResponseBodySamples = gatherResponseBodySamples;
 exports.selectPrimaryGraphQLOperation = selectPrimaryGraphQLOperation;
 exports.firstEndpointCapture = firstEndpointCapture;
 exports.firstEndpointPath = firstEndpointPath;
@@ -550,7 +551,7 @@ function inferZodSchemaFromSamples(samples, depth = 0, indent = "", opts = {}) {
     }
     if (kind === "object") {
         const objects = nonNull;
-        const keys = [...new Set(objects.flatMap((o) => Object.keys(o)))];
+        const keys = [...new Set(objects.flatMap((o) => Object.keys(o)))].filter((k) => !(opts.looseServerResponse && k === "__typename"));
         if (keys.length === 0)
             return wrap("z.record(z.string(), z.unknown())");
         const inner = `${indent}  `;
@@ -569,7 +570,8 @@ function inferZodSchemaFromSamples(samples, depth = 0, indent = "", opts = {}) {
             return `${inner}${isValidJsIdentifier(k) ? k : JSON.stringify(k)}: ${optional}`;
         })
             .join(",\n");
-        return wrap(`z.object({\n${fields},\n${indent}})`);
+        const objectExpr = `z.object({\n${fields},\n${indent}})${opts.looseServerResponse ? ".loose()" : ""}`;
+        return wrap(objectExpr);
     }
     return wrap("z.unknown()");
 }
@@ -687,8 +689,35 @@ function selectEffectiveResponseBody(isSubmissionFlow, actionSteps, replayRespon
         return replayResponseBody;
     return selectReturnAction(actionSteps)?.capture.responseBody ?? replayResponseBody;
 }
-function deriveBaseUrl(captures) {
-    for (const c of captures) {
+/**
+ * A capture's own URL is not guaranteed parseable (see the try/catch in
+ * `deriveBaseUrl` and `firstEndpointCapture` below), so host-provenance
+ * filtering must not throw on a malformed one — it just never matches.
+ */
+function captureHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * `baseUrl` itself is what {@link registrableDomain}'s fallback would be
+ * derived FROM, so at this point in generation the registrable-domain gate
+ * doesn't exist yet: when the flow declares no `ownBackendHostnames`, the
+ * best available signal is {@link isNoiseUrl}'s conservative exclusion of
+ * known third-party asset/tracking hosts (the same fallback
+ * `selectAuxFixtureCandidates` uses regardless of host-provenance data).
+ */
+function deriveBaseUrl(captures, ownBackendHostnames) {
+    const candidates = captures.filter((c) => {
+        if (ownBackendHostnames.length > 0) {
+            return (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, null);
+        }
+        return !(0, capture_filters_1.isNoiseUrl)(c.url);
+    });
+    for (const c of candidates) {
         try {
             const u = new URL(c.url);
             return `${u.protocol}//${u.host}`;
@@ -805,20 +834,94 @@ function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null)
 function isGraphQL(captures) {
     return captures.some((c) => c.operationName !== null);
 }
-function firstGraphQLQuery(captures) {
-    return captures.find((c) => c.query)?.query ?? null;
+/**
+ * The single own-backend capture the raw GraphQL fallback (no
+ * `selectPrimaryGraphQLOperation` winner) resolves its query, endpoint, and
+ * operationName from — all three MUST trace back to this same capture, not
+ * three independent array scans that could each land on a different one.
+ */
+function firstGraphQLCapture(captures, ownBackendHostnames = [], fallbackDomain = null) {
+    const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
+    return (captures.find((c) => c.query &&
+        (!hasHostProvenance ||
+            (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain))) ?? null);
+}
+/**
+ * Strips leading blank lines and `#`-comment lines (GraphQL comments run
+ * from `#` to end of line) so operation-signature regexes anchored at the
+ * `query`/`mutation` keyword still match documents preceded by a comment.
+ */
+function stripLeadingGraphQLComments(query) {
+    return query.replace(/^(?:[ \t]*(?:#[^\n]*)?\r?\n)*/, "");
 }
 /**
  * Parses `$name:` declarations out of a GraphQL operation signature, e.g.
- * `query cruiseSearch_Cruises($filters: String, $qualifiers: String)` yields
+ * `query catalogSearch_Catalog($filters: String, $qualifiers: String)` yields
  * `["filters", "qualifiers"]`.
  */
 function declaredOperationVariableNames(query) {
-    const signature = /^\s*(?:query|mutation)\s+\w*\s*\(([^)]*)\)/.exec(query);
+    const signature = /^\s*(?:query|mutation)\s+\w*\s*\(([^)]*)\)/.exec(stripLeadingGraphQLComments(query));
     if (!signature)
         return [];
     return Array.from(signature[1].matchAll(/\$(\w+)\s*:/g), (m) => m[1]);
 }
+/**
+ * Parses the operation name out of the query body itself, for captures whose
+ * top-level `operationName` field is null (an inline document with no
+ * separate operationName was still sent with a named `query`/`mutation`).
+ */
+function parsedOperationName(query) {
+    const signature = /^\s*(?:query|mutation)\s+(\w+)/.exec(stripLeadingGraphQLComments(query));
+    return signature?.[1] ?? null;
+}
+/**
+ * Groups a capture for recurrence counting by endpoint path + operation
+ * name (falling back to the name parsed out of the query body when
+ * `operationName` is null), so operationName-less inline documents that
+ * repeat the same underlying query are recognized as recurring instead of
+ * being permanently unjoinable.
+ */
+function operationGroupKey(capture) {
+    const endpointPath = (() => {
+        try {
+            return new URL(capture.url).pathname;
+        }
+        catch {
+            return "";
+        }
+    })();
+    const name = capture.operationName ?? parsedOperationName(capture.query ?? "") ?? "anonymous";
+    return `${endpointPath}::${name}`;
+}
+/**
+ * Every 2xx capture in the run sharing `winningCapture`'s operation identity
+ * (its `operationGroupKey` for a GraphQL winner, `endpointKey` for a
+ * plain-REST one), deduplicated by response body. A single recon run can
+ * capture the same read operation multiple times (pagination, re-filtering),
+ * and each occurrence is evidence for `inferZodSchemaFromSamples` about
+ * which fields the operation actually returns every time versus only
+ * sometimes -- evidence the winning capture alone can't provide.
+ */
+function gatherResponseBodySamples(winningCapture, isGraphQLWinner, captures) {
+    if (!winningCapture)
+        return [null];
+    const identityOf = (c) => isGraphQLWinner ? operationGroupKey(c) : endpointKey(c.url);
+    const winningIdentity = identityOf(winningCapture);
+    const seen = new Set();
+    const samples = [];
+    for (const c of captures) {
+        if (c.status < 200 || c.status >= 300)
+            continue;
+        if (identityOf(c) !== winningIdentity)
+            continue;
+        const serialized = JSON.stringify(c.responseBody);
+        if (seen.has(serialized))
+            continue;
+        seen.add(serialized);
+        samples.push(c.responseBody);
+    }
+    return samples.length > 0 ? samples : [winningCapture.responseBody];
+}
 /**
  * A declared variable is "populated" only by a non-null, non-empty-string
  * value — an operation can declare a filter input that every capture leaves
@@ -850,8 +953,19 @@ function isPopulatedVariableValue(value) {
  * Select answer (e.g. a device-type dropdown) never contributes a spurious
  * facet match to the ranking.
  */
-function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = process.env) {
-    const candidates = captures.filter((c) => c.status >= 200 && c.status < 300 && c.query !== null && !/^\s*mutation\b/.test(c.query));
+function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = process.env, ownBackendHostnames = [], fallbackDomain = null) {
+    // Callers with no host-provenance data (the exported function's unit
+    // tests) pass neither ownBackendHostnames nor fallbackDomain — in that
+    // case isAllowedFixtureHost would reject every candidate, so the gate
+    // only applies once the caller has actually resolved a notion of "own
+    // backend" to check against.
+    const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
+    const candidates = captures.filter((c) => c.status >= 200 &&
+        c.status < 300 &&
+        c.query !== null &&
+        !/^\s*mutation\b/.test(c.query) &&
+        (!hasHostProvenance ||
+            (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain)));
     if (candidates.length === 0)
         return null;
     const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary, env);
@@ -892,22 +1006,24 @@ function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = pr
         }
         return Object.values(c.variables).some((value) => spliceFacetsIntoStringVariable(value, payloadFieldList) !== null);
     };
+    // A facet-spliceable candidate must win over any non-facet candidate
+    // regardless of size/recurrence/phase — those signals only decide among
+    // candidates of the same facet-spliceability tier, never across tiers.
+    const facetCandidates = candidates.filter((c) => facetSpliceable(c));
+    const scoringPool = facetCandidates.length > 0 ? facetCandidates : candidates;
     const operationNameCounts = new Map();
-    for (const c of candidates) {
-        if (c.operationName === null)
-            continue;
-        operationNameCounts.set(c.operationName, (operationNameCounts.get(c.operationName) ?? 0) + 1);
+    for (const c of scoringPool) {
+        const key = operationGroupKey(c);
+        operationNameCounts.set(key, (operationNameCounts.get(key) ?? 0) + 1);
     }
-    const maxSize = Math.max(...candidates.map(responseSize), 1);
-    const maxFieldMatch = Math.max(...candidates.map(fieldMatchCount), 1);
+    const maxSize = Math.max(...scoringPool.map(responseSize), 1);
+    const maxFieldMatch = Math.max(...scoringPool.map(fieldMatchCount), 1);
     const maxRecurrence = Math.max(...Array.from(operationNameCounts.values()), 1);
-    const scored = candidates.map((capture) => {
+    const scored = scoringPool.map((capture) => {
         const sizeScore = responseSize(capture) / maxSize;
         const fieldScore = fieldMatchCount(capture) / maxFieldMatch;
         const phaseScore = capture.phase !== "home" ? 1 : 0;
-        const recurrenceScore = capture.operationName !== null
-            ? (operationNameCounts.get(capture.operationName) ?? 0) / maxRecurrence
-            : 0;
+        const recurrenceScore = (operationNameCounts.get(operationGroupKey(capture)) ?? 0) / maxRecurrence;
         const facetScore = facetSpliceable(capture) ? 1 : 0;
         // Field correlation carries the heaviest weight so a smaller facet-matching
         // operation outranks a larger decoy — size alone must not decide this.
@@ -929,9 +1045,8 @@ function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = pr
             return firstEndpointPath(candidates);
         }
     })();
-    const sharedCaptures = winner.capture.operationName !== null
-        ? candidates.filter((c) => c.operationName === winner.capture.operationName)
-        : [winner.capture];
+    const winnerGroupKey = operationGroupKey(winner.capture);
+    const sharedCaptures = candidates.filter((c) => operationGroupKey(c) === winnerGroupKey);
     const declaredVariableNames = declaredOperationVariableNames(winner.capture.query ?? "");
     const unpopulatedDeclaredVariables = declaredVariableNames.filter((name) => !sharedCaptures.some((c) => isPopulatedVariableValue(c.variables?.[name])));
     return { capture: winner.capture, endpointPath, unpopulatedDeclaredVariables };
@@ -941,8 +1056,16 @@ function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = pr
  * derives a path string from, so non-GraphQL flows can also read that
  * capture's own `.responseBody` instead of an array-order-first replay.
  */
-function firstEndpointCapture(captures) {
-    const nonGetCaptures = captures.filter((c) => c.method !== "GET");
+function firstEndpointCapture(captures, ownBackendHostnames = [], fallbackDomain = null) {
+    // Callers with no host-provenance data (unit tests exercising the
+    // chronological-first fallback in isolation) pass neither argument -- in
+    // that case isAllowedFixtureHost would reject every candidate, so the
+    // gate only applies once the caller has actually resolved a notion of
+    // "own backend" to check against. Mirrors selectPrimaryGraphQLOperation.
+    const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
+    const allowed = (c) => !hasHostProvenance ||
+        (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain);
+    const nonGetCaptures = captures.filter((c) => c.method !== "GET" && allowed(c));
     for (const c of nonGetCaptures) {
         try {
             new URL(c.url);
@@ -952,7 +1075,7 @@ function firstEndpointCapture(captures) {
             // skip
         }
     }
-    for (const c of captures) {
+    for (const c of captures.filter(allowed)) {
         try {
             new URL(c.url);
             return c;
@@ -963,9 +1086,17 @@ function firstEndpointCapture(captures) {
     }
     return null;
 }
-function firstEndpointPath(captures) {
+function safeUrlPathname(url) {
     try {
-        const capture = firstEndpointCapture(captures);
+        return new URL(url).pathname;
+    }
+    catch {
+        return "/api/search";
+    }
+}
+function firstEndpointPath(captures, ownBackendHostnames = [], fallbackDomain = null) {
+    try {
+        const capture = firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain);
         return capture ? new URL(capture.url).pathname : "/api/search";
     }
     catch {
@@ -1079,8 +1210,6 @@ function extractGraphQLActionSequence(captures, submitPatterns = null) {
     return captures
         .map((capture, index) => ({ capture, index }))
         .filter(({ capture }) => {
-        if (capture.operationName === null)
-            return false;
         if (capture.status < 200 || capture.status >= 300)
             return false;
         if ((0, capture_filters_1.isNoiseUrl)(capture.url))
@@ -3398,7 +3527,7 @@ function emitMultiStepExecuteHttp(actions, inputBody, errorSignals, fieldNameMap
         // validates any individual call. Without this override, HttpRequestInit.schema
         // would default to the client's z.unknown() and narrowing the caller-facing
         // contract would enforce that narrowed shape on every call in the chain.
-        const schemaExpr = inferZodSchema(cap.responseBody);
+        const schemaExpr = inferZodSchema(cap.responseBody, 0, "", { looseServerResponse: true });
         rendered.push({ url, method: cap.method, headersExpr, bodyArg, schemaExpr });
     }
     // Identifier scan against the rendered text — captures `${foo}`, `${foo.bar}`,
@@ -3879,7 +4008,7 @@ function buildContractChecklist(opts) {
     ].filter((line) => line !== "");
 }
 function emitContractTs(opts) {
-    const { siteId, pascal, baseUrl, baseHeaders, minTime, safeRps, hasRateLimitProbeData = false, responseBody, gql, gqlQuery, endpointPath, gqlOperationName, gqlVariables, auxFiles, multiStepBody, omitExecuteHttp = false, isSubmissionFlow = false, inputBody, hasMultipartStep = false, discoveredFormFields, fieldOptionsMap, discoveredOptionFields, discoveredRawOptionFields, discoveredAdditionalBodyKeys, discoveredStructuredKeys, payloadFieldNames, headerBindings = [], } = opts;
+    const { siteId, pascal, baseUrl, baseHeaders, minTime, safeRps, hasRateLimitProbeData = false, responseBody, responseBodySamples = [responseBody], gql, gqlQuery, endpointPath, gqlOperationName, gqlVariables, auxFiles, multiStepBody, omitExecuteHttp = false, isSubmissionFlow = false, inputBody, hasMultipartStep = false, discoveredFormFields, fieldOptionsMap, discoveredOptionFields, discoveredRawOptionFields, discoveredAdditionalBodyKeys, discoveredStructuredKeys, payloadFieldNames, headerBindings = [], } = opts;
     // This is the CLIENT-level schema — createHttpClient's default, and the
     // plugin's caller-facing contract (what executeHttp's return value promises
     // its own caller). It does NOT validate any individual call in a multi-step
@@ -3908,7 +4037,10 @@ function emitContractTs(opts) {
         ? `z.object({ verified: z.boolean() })`
         : omitExecuteHttp
             ? `z.unknown()`
-            : inferZodSchema(responseBody, 0, "", { conditionalFieldNames });
+            : inferZodSchemaFromSamples(responseBodySamples, 0, "", {
+                conditionalFieldNames,
+                looseServerResponse: true,
+            });
     // Multi-step flows that include a multipart upload need the binary asset
     // on the payload. ApplicantContactSchema (via ApplicantResumeSchema) already
     // declares Resume/ResumeContentType/ResumeFilename, so submission flows
@@ -4150,7 +4282,7 @@ function emitContractTs(opts) {
             ? `import { createGraphqlClient } from "${ENGINE_PKG}/scraper/graphql-client";`
             : `import { createHttpClient } from "${ENGINE_PKG}/scraper/http-client";`;
     const queryConst = !omitExecuteHttp && gql && gqlQuery
-        ? `\n// Lifted verbatim from recon capture — trim UI-only fields before shipping.\nconst ${pascal.toUpperCase()}_QUERY = \`${gqlQuery.trim()}\`;\n`
+        ? `\n// Lifted verbatim from recon capture. The adjacent response schema is drift-tolerant by construction (dropped __typename, .loose() objects), so this query text is not hand-trimmed.\nconst ${pascal.toUpperCase()}_QUERY = \`${gqlQuery.trim()}\`;\n`
         : "";
     const gqlCacheBlock = omitExecuteHttp
         ? ""
@@ -4923,7 +5055,15 @@ async function main() {
     // null the recovery functions no-op — the engine hardcodes no vendor format.
     const formSchema = await resolveFormSchema(formSchemaSpecifier);
     const pascal = toPascalCase(siteId);
-    const baseUrl = deriveBaseUrl(captures);
+    // Read the flow's declared own-backend hosts BEFORE deriving baseUrl, so
+    // deriveBaseUrl itself can gate on them: a third-party host that happens
+    // to capture first (a feature-flag SDK, an analytics vendor) must never
+    // become the generated hot path's base URL. baseUrl's own
+    // registrable-domain fallback is necessarily derived FROM baseUrl, so it
+    // isn't available to deriveBaseUrl yet -- see deriveBaseUrl's own doc
+    // comment for how it copes when ownBackendHostnames is empty.
+    const ownBackendHostnames = (0, recon_shared_1.readOwnBackendHostnames)(flowFile);
+    const baseUrl = deriveBaseUrl(captures, ownBackendHostnames);
     // Gate on the flow's declared own-backend hosts (or the registrable-domain
     // fallback of baseUrl) via the same predicate recon-http.ts applies at
     // write time, so a stale aux/ directory from before that filter existed
@@ -4931,7 +5071,6 @@ async function main() {
     // third party's JSON into a generated plugin's fixtures/. A file with no
     // manifest entry is unverifiable provenance, not proven safe, so it is
     // excluded rather than assumed to have passed the write-time filter.
-    const ownBackendHostnames = (0, recon_shared_1.readOwnBackendHostnames)(flowFile);
     const fallbackDomain = baseUrl.length > 0 ? (0, capture_filters_1.registrableDomain)(new URL(baseUrl).hostname) : null;
     const auxFiles = auxManifest
         .filter((entry) => {
@@ -4967,21 +5106,42 @@ async function main() {
     // (further down) read the same computed sequence instead of calling the
     // extractor twice.
     const graphqlActionSequence = gql ? extractGraphQLActionSequence(captures, submitPatterns) : [];
-    const isReadOnlyFlow = !flowSteps.some((step) => typeof step !== "string" && step.submitStep === true);
-    const primaryGraphQLOperation = gql && isReadOnlyFlow && graphqlActionSequence.length === 0
-        ? selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary)
+    const primaryGraphQLOperation = gql && graphqlActionSequence.length === 0
+        ? selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, process.env, ownBackendHostnames, fallbackDomain)
         : null;
     if (primaryGraphQLOperation && primaryGraphQLOperation.unpopulatedDeclaredVariables.length > 0) {
         const operationLabel = primaryGraphQLOperation.capture.operationName ?? "(anonymous)";
         logger.warn(`WARN primary GraphQL operation '${operationLabel}' declares filter variable(s) ${primaryGraphQLOperation.unpopulatedDeclaredVariables.join(", ")} that are never populated in any capture — the generated executeHttp's payload field(s) for ${primaryGraphQLOperation.unpopulatedDeclaredVariables.join(", ")} have no wiring target and will replay the captured frozen value instead of the caller's input`);
     }
-    const gqlQuery = primaryGraphQLOperation?.capture.query ?? firstGraphQLQuery(captures);
-    const endpointPath = primaryGraphQLOperation?.endpointPath ?? firstEndpointPath(captures);
+    // When there's no primaryGraphQLOperation winner but the flow is still
+    // GraphQL, the query/endpointPath/responseBody/operationName fallbacks
+    // must all trace back to the SAME capture (firstGraphQLCapture) rather
+    // than resolving independently — a non-GraphQL-shaped own-backend
+    // capture could otherwise win the endpoint/body fallback while an
+    // unrelated capture supplies the query text.
+    const fallbackGraphQLCapture = gql
+        ? firstGraphQLCapture(captures, ownBackendHostnames, fallbackDomain)
+        : null;
+    const gqlQuery = primaryGraphQLOperation?.capture.query ?? fallbackGraphQLCapture?.query ?? null;
+    const endpointPath = primaryGraphQLOperation?.endpointPath ??
+        (fallbackGraphQLCapture
+            ? safeUrlPathname(fallbackGraphQLCapture.url)
+            : firstEndpointPath(captures, ownBackendHostnames, fallbackDomain));
     // Derived from the primary operation's own Phase-1 capture, never from
     // replay array order -- a replay's body reflects whichever endpoint fired
     // first, not necessarily the primary operation, and only exists once
     // recon:http has run.
-    const responseBody = (primaryGraphQLOperation?.capture ?? firstEndpointCapture(captures))?.responseBody ?? null;
+    const winningCapture = primaryGraphQLOperation?.capture ??
+        fallbackGraphQLCapture ??
+        firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain);
+    const responseBody = winningCapture?.responseBody ?? null;
+    // Every 2xx capture sharing the winning capture's operation identity, not
+    // just the one that happened to win selection -- a paginated/re-filtered
+    // re-fire of the same operation can omit a field the winning capture
+    // happened to have (or vice versa), and inferZodSchemaFromSamples needs
+    // that presence evidence across occurrences to mark the field .optional()
+    // instead of required from a single observation.
+    const responseBodySamples = gatherResponseBodySamples(winningCapture, primaryGraphQLOperation !== null || fallbackGraphQLCapture !== null, captures);
     // Detect a multi-step submission flow (transactional sites like apply forms,
     // checkout, etc.). When the action sequence has 2+ POSTs, switch the
     // contract template to emit a state-threaded executeHttp.
@@ -5257,10 +5417,19 @@ async function main() {
         safeRps,
         hasRateLimitProbeData,
         responseBody: effectiveResponseBody,
+        // selectEffectiveResponseBody already resolves a submission flow's own
+        // single terminal capture -- the multi-sample evidence gathered above
+        // describes the (possibly different) read-flow winning capture and
+        // doesn't apply once a submission flow has picked its own return call.
+        responseBodySamples: isSubmissionFlow ? [effectiveResponseBody] : responseBodySamples,
         gql,
         gqlQuery,
         endpointPath,
-        gqlOperationName: primaryGraphQLOperation?.capture.operationName ?? null,
+        gqlOperationName: primaryGraphQLOperation
+            ? (primaryGraphQLOperation.capture.operationName ??
+                parsedOperationName(primaryGraphQLOperation.capture.query ?? ""))
+            : (fallbackGraphQLCapture?.operationName ??
+                parsedOperationName(fallbackGraphQLCapture?.query ?? "")),
         gqlVariables: primaryGraphQLOperation?.capture.variables ?? null,
         auxFiles,
         multiStepBody,