@enricai/barnacle 1.12.56 → 1.12.58

package/dist/scripts/recon-generate.js

@@ -932,8 +932,11 @@ function selectReturnAction(steps) {
  * getGql/httpClient emission's own fold-merge loop (see `emitContractTs`)
  * adds at runtime.
  */
-function selectEffectiveResponseBody(isSubmissionFlow, actionSteps, replayResponseBody, foldReturnSpec = null) {
-    const foldPlans = resolveFoldPlan(actionSteps, foldReturnSpec);
+function selectEffectiveResponseBody(isSubmissionFlow, actionSteps, replayResponseBody, foldReturnSpec = null, 
+// See resolveFoldPlan's identical parameter — threaded through so shape
+// inference can't disagree with emitContractTs's own emitted-primary anchor.
+primaryIdentityAnchor = null) {
+    const foldPlans = resolveFoldPlan(actionSteps, foldReturnSpec, primaryIdentityAnchor);
     const lastFoldPlan = foldPlans[foldPlans.length - 1] ?? null;
     if (foldPlans.length <= 1) {
         if (lastFoldPlan)
@@ -1116,7 +1119,7 @@ function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null,
     return baseline;
 }
 function isGraphQL(captures) {
-    return captures.some((c) => c.operationName !== null);
+    return captures.some((c) => c.operationName !== null || (0, capture_filters_1.parsedOperationName)(c.query ?? "") !== null);
 }
 /**
  * The single own-backend capture the raw GraphQL fallback (no
@@ -1168,15 +1171,6 @@ function declaredOperationVariableNames(query) {
         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
@@ -1193,7 +1187,23 @@ function operationGroupKey(capture) {
             return "";
         }
     })();
-    const name = capture.operationName ?? parsedOperationName(capture.query ?? "") ?? "anonymous";
+    const name = capture.operationName ?? (0, capture_filters_1.parsedOperationName)(capture.query ?? "") ?? "anonymous";
+    return `${endpointPath}::${name}`;
+}
+/**
+ * The identity (in {@link operationGroupKey}'s `endpointPath::operationName`
+ * format) of the GraphQL operation already selected upstream as this run's
+ * emitted primary — `null` for a REST primary, since fold-plan/emitted-primary
+ * drift is a GraphQL-only concern (a REST primary has no operationName to
+ * diverge on in the first place). Shared verbatim by {@link emitContractTs}
+ * and the "no fold plan resolved" diagnostic in `main()` so both anchor
+ * `resolveFoldPlan`/`resolveApplicableFoldPlans` to the SAME identity and can
+ * never independently resolve a different primary.
+ */
+function computeEmittedPrimaryAnchor(gql, endpointPath, gqlOperationName, gqlQuery) {
+    if (!gql)
+        return null;
+    const name = gqlOperationName ?? (0, capture_filters_1.parsedOperationName)(gqlQuery ?? "") ?? "anonymous";
     return `${endpointPath}::${name}`;
 }
 /**
@@ -1610,7 +1620,12 @@ function extractActionSequence(captures, submitPatterns = null, foldReturnSpec =
             const otherPaths = hostGated
                 .filter((h, j) => denselyNameSpaced ? safeUrlPathname(h.capture.url) !== path : j !== i)
                 .map((h) => safeUrlPathname(h.capture.url));
-            return !(0, capture_filters_1.isStructurallyIsolatedCapture)(path, otherPaths);
+            // A capture admitted via the flow's own declared foldReturnSpec
+            // endpointPattern (the drill-down target) is authoritative by
+            // construction — the flow author named it explicitly — so it is
+            // exempt from token-overlap isolation, which exists to catch
+            // INCIDENTAL same-host captures the flow never declared.
+            return matchesFoldReturn(capture) || !(0, capture_filters_1.isStructurallyIsolatedCapture)(path, otherPaths);
         })
         : hostGated;
     // Narrow further using structural relevance, anchored on whichever
@@ -7585,7 +7600,14 @@ function scanPrimaryCandidateGroups(actions, primaryIndex, globallyConsumedIndic
     }
     return groups;
 }
-function detectDrillDownFoldPlan(actions) {
+function detectDrillDownFoldPlan(actions, 
+// When set (see computeEmittedPrimaryAnchor), constrains the outer loop's
+// primary candidate search to only the action whose own operationGroupKey
+// matches this identity, so this can never resolve a fold plan anchored on
+// a DIFFERENT operation than the one already selected upstream as this
+// run's emitted primary. `null`/omitted preserves today's unconstrained,
+// order-dependent structural search for every other call site.
+primaryIdentityAnchor = null) {
     const plans = [];
     // Spans every primary candidate, not just the current one's own drill
     // scan: a step already folded into an earlier plan's chain — as either
@@ -7626,6 +7648,10 @@ function detectDrillDownFoldPlan(actions) {
         if (globallyConsumedIndices.has(primaryIndex))
             continue;
         const primary = actions[primaryIndex];
+        if (primaryIdentityAnchor !== null &&
+            operationGroupKey(primary.capture) !== primaryIdentityAnchor) {
+            continue;
+        }
         const groups = scanCached(primaryIndex);
         if (groups.length === 0)
             continue;
@@ -8136,7 +8162,10 @@ function compileFoldReturnResultsMatcher(spec) {
     const resultsPath = spec.resultsPath.split(".");
     return (capture) => objectItemsAtPath(capture.responseBody, resultsPath) !== null;
 }
-function buildFoldPlanFromSpec(actions, spec) {
+function buildFoldPlanFromSpec(actions, spec, 
+// See detectDrillDownFoldPlan's identical parameter — constrains this
+// function's own primaryStepIndex loop to the same anchor identity.
+primaryIdentityAnchor = null) {
     const primaryArrayPath = spec.resultsPath.split(".");
     const matchesFoldReturnEndpoint = compileFoldReturnEndpointMatcher(spec);
     // Built once and shared across every primaryStepIndex — see
@@ -8147,6 +8176,10 @@ function buildFoldPlanFromSpec(actions, spec) {
     const requestValueIndex = buildRequestValueIndex(actions);
     let freshestPlan = null;
     for (let primaryStepIndex = 0; primaryStepIndex < actions.length; primaryStepIndex++) {
+        if (primaryIdentityAnchor !== null &&
+            operationGroupKey(actions[primaryStepIndex].capture) !== primaryIdentityAnchor) {
+            continue;
+        }
         const primaryItems = objectItemsAtPath(actions[primaryStepIndex].capture.responseBody, primaryArrayPath);
         if (!primaryItems)
             continue;
@@ -8305,10 +8338,15 @@ function isDescendantArrayPath(candidate, base) {
  * spec's own drill indices look independent, so the heuristic's wrong-level
  * guess never survives alongside the corrected one.
  */
-function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec) {
+function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec, 
+// See detectDrillDownFoldPlan's identical parameter. Threaded into this
+// function's own buildFoldPlanFromSpec call so a spec plan resolved here
+// can never anchor on a DIFFERENT primary than the (already anchor-
+// constrained) structuralPlans it's about to be merged onto.
+primaryIdentityAnchor = null) {
     if (foldReturnSpec === null)
         return [...structuralPlans];
-    const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec);
+    const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor);
     if (specPlan === null)
         return [...structuralPlans];
     const specPrimaryEndpointKey = endpointKey(actions[specPlan.primaryStepIndex].capture.url);
@@ -8660,14 +8698,17 @@ function collectDependentDrillDownChainValues(actions, foldReturnSpec) {
     }
     return consumersByValue;
 }
-function resolveFoldPlan(actions, foldReturnSpec = null) {
-    const structuralPlans = detectDrillDownFoldPlan(actions);
+function resolveFoldPlan(actions, foldReturnSpec = null, 
+// See detectDrillDownFoldPlan's identical parameter — threaded through to
+// both the structural and spec-driven resolution paths below.
+primaryIdentityAnchor = null) {
+    const structuralPlans = detectDrillDownFoldPlan(actions, primaryIdentityAnchor);
     const plans = structuralPlans.length > 0
-        ? mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec)
+        ? mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec, primaryIdentityAnchor)
         : (() => {
             if (foldReturnSpec === null)
                 return [];
-            const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec);
+            const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor);
             return specPlan === null ? [] : [specPlan];
         })();
     return plans.flatMap((plan) => {
@@ -8694,10 +8735,14 @@ function resolveFoldPlan(actions, foldReturnSpec = null) {
  * `primaryStepIndex`) per distinct primaryArrayPath/endpoint before
  * returning, keeping `resolveFoldPlan`'s own multi-plan output untouched.
  */
-function resolveApplicableFoldPlans(actions, foldReturnSpec, multiStepBody) {
+function resolveApplicableFoldPlans(actions, foldReturnSpec, multiStepBody, 
+// See detectDrillDownFoldPlan's identical parameter — threaded through so
+// this function's single-primary output can never diverge from the
+// caller's already-selected emitted primary.
+primaryIdentityAnchor = null) {
     if (multiStepBody)
         return [];
-    const plans = resolveFoldPlan(actions, foldReturnSpec);
+    const plans = resolveFoldPlan(actions, foldReturnSpec, primaryIdentityAnchor);
     const primaryKey = (plan) => `${endpointKey(actions[plan.primaryStepIndex].capture.url)}\u0000${plan.primaryArrayPath.join(".")}`;
     const freshestStepIndexByPrimary = new Map();
     for (const plan of plans) {
@@ -9163,28 +9208,17 @@ function emitContractTs(opts) {
     // buildPaginatedFetchLoopExecuteHttpBody) — the fold runs against the final
     // assembled/de-duplicated page items, not just the first page's captured
     // sample, so a paginated primary is no longer excluded from folding.
-    const singlePrimaryFoldPlans = resolveApplicableFoldPlans(actionSteps, foldReturnSpec, multiStepBody);
-    // A fold plan's primaryStepIndex is resolved purely structurally (does the
-    // declared resultsPath resolve to an object array on that capture), with
-    // no comparison against the operation actually selected as primary for
-    // emission (gqlOperationName/gqlQuery, computed independently upstream).
-    // When they diverge, buildFoldMergeLines below would cast `data` to the
-    // fold plan's operation's shape even though `data` at runtime holds the
-    // emitted primary operation's response — a cast that can never typecheck.
-    // Scoped to gql: REST fold-plan/emitted-primary drift is a distinct,
-    // undocumented concern out of scope here.
-    if (gql) {
-        const emittedPrimaryIdentity = `${endpointPath}::${gqlOperationName ?? parsedOperationName(gqlQuery ?? "") ?? "anonymous"}`;
-        for (const plan of singlePrimaryFoldPlans) {
-            const primaryStep = actionSteps[plan.primaryStepIndex];
-            if (!primaryStep)
-                continue;
-            const foldPrimaryIdentity = operationGroupKey(primaryStep.capture);
-            if (foldPrimaryIdentity !== emittedPrimaryIdentity) {
-                throw new Error(`emitContractTs: fold plan primary operation ${foldPrimaryIdentity} differs from the emitted primary operation ${emittedPrimaryIdentity} — the declared foldReturn no longer applies to this run's selected primary; drop or re-resolve the foldReturn spec against the emitted primary operation`);
-            }
-        }
-    }
+    // Constrains the resolution below to the operation already selected as
+    // this run's emitted primary (gqlOperationName/gqlQuery, computed
+    // independently upstream) — see computeEmittedPrimaryAnchor. Without this,
+    // a fold plan's primaryStepIndex was resolved purely structurally (does
+    // the declared resultsPath resolve to an object array on that capture),
+    // with no anchor to the emitted primary, so it could resolve onto a
+    // DIFFERENT operation than the one `data` holds at runtime. Scoped to gql:
+    // REST fold-plan/emitted-primary drift is a distinct, undocumented concern
+    // out of scope here.
+    const emittedPrimaryAnchor = computeEmittedPrimaryAnchor(gql, endpointPath, gqlOperationName, gqlQuery);
+    const singlePrimaryFoldPlans = resolveApplicableFoldPlans(actionSteps, foldReturnSpec, multiStepBody, emittedPrimaryAnchor);
     // A GraphQL primary with a resolved drill-down fold has no other REST
     // client to issue the drill request(s) with — getGql only ever speaks
     // GraphQL to the primary endpoint.
@@ -11187,9 +11221,21 @@ async function main() {
         }
         const hasMultipartStep = actionSteps.some((s) => s.isMultipart);
         const headerBindings = collectHeaderBindings(actionSteps);
+        // Mirrors the exact gqlOperationName expression fed into contractOpts
+        // below (see the `gqlOperationName:` field), so this anchor can never
+        // disagree with the one emitContractTs computes from that same
+        // contractOpts — see computeEmittedPrimaryAnchor.
+        const emittedPrimaryAnchor = computeEmittedPrimaryAnchor(gql, endpointPath, primaryGraphQLOperation
+            ? (primaryGraphQLOperation.capture.operationName ??
+                (0, capture_filters_1.parsedOperationName)(primaryGraphQLOperation.capture.query ?? ""))
+            : (fallbackGraphQLCapture?.operationName ??
+                (0, capture_filters_1.parsedOperationName)(fallbackGraphQLCapture?.query ?? "")), gqlQuery);
         // Shape inference targets the SAME call executeHttp returns — see
         // selectEffectiveResponseBody — so the two surfaces can't describe different calls.
-        const effectiveResponseBody = selectEffectiveResponseBody(isSubmissionFlow, actionSteps, responseBody, foldReturnSpec);
+        // A submission flow's fold plan must stay byte-identical to
+        // emitMultiStepExecuteHttp's own unanchored resolveFoldPlan call, which the
+        // actual multi-step runtime loop uses — so the anchor is withheld there.
+        const effectiveResponseBody = selectEffectiveResponseBody(isSubmissionFlow, actionSteps, responseBody, foldReturnSpec, isSubmissionFlow ? null : emittedPrimaryAnchor);
         // A declared foldReturn that resolves to no plan is a silent no-op otherwise
         // — the flow author gets the discarding selectReturnAction path with nothing
         // in the output saying their declaration never applied. A multi-step
@@ -11202,7 +11248,8 @@ async function main() {
         // with a working foldReturn.
         const effectiveFoldPlanCount = multiStepBody
             ? resolveFoldPlan(actionSteps, foldReturnSpec).length
-            : resolveApplicableFoldPlans(actionSteps, foldReturnSpec, multiStepBody).length;
+            : resolveApplicableFoldPlans(actionSteps, foldReturnSpec, multiStepBody, emittedPrimaryAnchor)
+                .length;
         if (foldReturnSpec !== null && effectiveFoldPlanCount === 0) {
             logger.warn(`flow declares foldReturn (endpointPattern: ${foldReturnSpec.endpointPattern}, resultsPath: ${foldReturnSpec.resultsPath}, joinFields: ${foldReturnSpec.joinFields.join(", ")}) but no fold plan resolved — no later capture matched the endpoint pattern, resultsPath resolved to no object array, or the matched drill-down is multipart; the drill-down's response will not be folded`);
         }
@@ -11265,9 +11312,9 @@ async function main() {
             endpointPath,
             gqlOperationName: primaryGraphQLOperation
                 ? (primaryGraphQLOperation.capture.operationName ??
-                    parsedOperationName(primaryGraphQLOperation.capture.query ?? ""))
+                    (0, capture_filters_1.parsedOperationName)(primaryGraphQLOperation.capture.query ?? ""))
                 : (fallbackGraphQLCapture?.operationName ??
-                    parsedOperationName(fallbackGraphQLCapture?.query ?? "")),
+                    (0, capture_filters_1.parsedOperationName)(fallbackGraphQLCapture?.query ?? "")),
             // For a REST primary (no primaryGraphQLOperation), the winning
             // capture's own `variables`/`decodedParams` is the REST equivalent of
             // a GraphQL operation's captured variables — the object