@enricai/barnacle 1.12.47 → 1.12.49

package/dist/scripts/recon-generate.js

@@ -1744,6 +1744,110 @@ function collapseRedundantPatches(actions) {
         return lastPatchByPath.get(path) === i;
     });
 }
+/** Request field name shapes that identify a paged/offset-style re-query --
+ * the REST analog of {@link PAGE_SIZE_KEY_PATTERN}/{@link SKIP_KEY_PATTERN},
+ * loosened to match a single paging cursor field on its own (a plain `page`
+ * counter, unpaired with an explicit page-size key) since that is the common
+ * REST shape, unlike GraphQL's paired variables convention. */
+const PAGINATION_FIELD_NAME_PATTERN = /^(page|pagenum|pagenumber|pageindex|pageno|offset|skip|start|cursor)$/i;
+/** Every query-string and (when JSON-object-shaped) request-body field on a
+ * capture, merged into one comparable map -- REST pagination/facet state can
+ * live in either depending on the endpoint's own convention. */
+function captureRequestFields(capture) {
+    const fields = {};
+    try {
+        const url = new URL(capture.url);
+        for (const [key, value] of url.searchParams)
+            fields[key] = value;
+    }
+    catch {
+        // Relative/invalid URLs carry no query-string signal to merge in.
+    }
+    if (capture.requestPostData) {
+        try {
+            const parsed = JSON.parse(capture.requestPostData);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                Object.assign(fields, parsed);
+            }
+        }
+        catch {
+            // A non-JSON body carries no per-field signal to merge in.
+        }
+    }
+    return fields;
+}
+/**
+ * A same-endpoint capture group qualifies for collapsing when every capture
+ * resolves to the same {@link responseShapeKey} (ruling out a mutation POST,
+ * whose response is a single mutated object rather than an array, and any
+ * group whose members diverge in response shape) AND its request fields vary
+ * in at most one field once known non-semantic noise keys ({@link
+ * CACHE_BUSTER_QUERY_KEYS}) are excluded from consideration, and that
+ * remaining field is pagination-shaped -- a paged listing/facet re-query --
+ * or vary in no field at all -- a polled toggles/feature-flag endpoint
+ * re-fired with an identical request. A group
+ * whose members vary in a non-pagination field (e.g. a per-item drill's
+ * item-id body field) is left untouched: that variance carries the distinct
+ * per-item state the existing fold-chain mechanism (`target.chain` in
+ * `emitMultiStepExecuteHttp`) already hoists correctly once resolved, and
+ * collapsing it here would erase the very state that hoisting depends on.
+ */
+function isRedundantSameEndpointGroup(group) {
+    const shapeKey = responseShapeKey(group[0].capture);
+    if (shapeKey === null)
+        return false;
+    if (!group.every((a) => responseShapeKey(a.capture) === shapeKey))
+        return false;
+    const fieldSets = group.map((a) => captureRequestFields(a.capture));
+    const allKeys = new Set();
+    for (const fields of fieldSets) {
+        for (const key of Object.keys(fields))
+            allKeys.add(key);
+    }
+    const varyingKeys = [...allKeys].filter((key) => {
+        if (CACHE_BUSTER_QUERY_KEYS.has(key))
+            return false;
+        const values = new Set(fieldSets.map((fields) => JSON.stringify(fields[key])));
+        return values.size > 1;
+    });
+    if (varyingKeys.length === 0)
+        return true;
+    return varyingKeys.length === 1 && PAGINATION_FIELD_NAME_PATTERN.test(varyingKeys[0]);
+}
+/**
+ * REST counterpart of {@link dedupRedundantSameOperationCaptures}: collapses
+ * each same-endpoint (method + {@link endpointKey}) group that qualifies per
+ * {@link isRedundantSameEndpointGroup} down to its FIRST occurrence. A paged
+ * listing re-fired across pages/facets, or a polled toggles endpoint re-fired
+ * with an identical request, carries no distinct state for downstream steps
+ * to thread; every other same-endpoint group (including a per-item drill
+ * varying by item id) is left exactly as extracted. Kept representative is
+ * the first occurrence, not the last, because a later step's fold/join (see
+ * `buildFoldPlanFromSpec`) resolves its item-level join values against
+ * whichever page's response survives — page 1 is what a browsing/drill flow
+ * actually saw and drilled into first, so it is the occurrence downstream
+ * join values are captured against, not the endpoint's final paged state.
+ */
+function collapseRedundantSameEndpointCaptures(actions) {
+    const positionsByGroup = new Map();
+    actions.forEach((a, i) => {
+        const key = `${a.capture.method} ${endpointKey(a.capture.url)}`;
+        const positions = positionsByGroup.get(key) ?? [];
+        positions.push(i);
+        positionsByGroup.set(key, positions);
+    });
+    const drop = new Set();
+    for (const positions of positionsByGroup.values()) {
+        if (positions.length < 2)
+            continue;
+        const group = positions.map((i) => actions[i]);
+        if (!isRedundantSameEndpointGroup(group))
+            continue;
+        for (const position of positions.slice(1))
+            drop.add(position);
+    }
+    return actions.filter((_, i) => !drop.has(i));
+}
 /**
  * Recursively walks a JSON value and yields every string leaf, paired with its
  * JSON path. Numbers/booleans/nulls are skipped — only string leaves are
@@ -6005,7 +6109,7 @@ function detectDrillDownFoldPlan(actions) {
             // A re-queried primary (same endpoint hit more than once, per
             // findRequeriedActions) can have MULTIPLE occurrences that each
             // independently thread a join key into the SAME later drill-down —
-            // e.g. two "available-products" calls that both happen to contain the
+            // e.g. two "list-items" calls that both happen to contain the
             // item the drill-down looks up. selectReturnAction/selectPayloadAction
             // already establish freshest-wins for this exact re-queried-primary
             // case, so the plan must anchor on the LAST such occurrence, not the
@@ -8434,15 +8538,29 @@ function resolvedPrimaryResponseCapture(result) {
         return result.winningCapture;
     return selectReturnAction(result.actionSteps)?.capture ?? null;
 }
-/** True when `capture`'s own top-level response JSON is the field's source —
- * the same "does this capture's response carry the field" signal
- * {@link assertRequiredUrlFieldsReferenced} implicitly relies on, applied per
- * capture instead of to the merged emitted code. */
-function captureOwnsTopLevelField(capture, fieldName) {
-    const body = capture.responseBody;
-    if (typeof body !== "object" || body === null || Array.isArray(body))
+/** True when `fieldName` is an own key of `value` at any nesting depth up to
+ * `maxDepth`, walking plain objects and arrays — the same recursion the
+ * schema-inference walk ({@link inferZodSchema}, bounded by
+ * {@link DEFAULT_MAX_INFER_DEPTH}) uses to discover fields in the first
+ * place, so attribution can't miss a field the inference walk found. */
+function hasOwnFieldAtAnyDepth(value, fieldName, maxDepth) {
+    if (maxDepth < 0 || typeof value !== "object" || value === null)
         return false;
-    return Object.hasOwn(body, fieldName);
+    if (Array.isArray(value)) {
+        return value.some((item) => hasOwnFieldAtAnyDepth(item, fieldName, maxDepth - 1));
+    }
+    const record = value;
+    if (Object.hasOwn(record, fieldName))
+        return true;
+    return Object.values(record).some((child) => hasOwnFieldAtAnyDepth(child, fieldName, maxDepth - 1));
+}
+/** True when `capture`'s response JSON carries the field's source anywhere in
+ * its nested shape — the same "does this capture's response carry the field"
+ * signal {@link assertRequiredUrlFieldsReferenced} implicitly relies on,
+ * applied per capture instead of to the merged emitted code, walked to the
+ * same depth the schema-inference walk supports. */
+function captureOwnsTopLevelField(capture, fieldName) {
+    return hasOwnFieldAtAnyDepth(capture.responseBody, fieldName, DEFAULT_MAX_INFER_DEPTH);
 }
 /**
  * Builds the "field(s) ... capture(s) ..." detail the intent requires a
@@ -8467,11 +8585,23 @@ function describeOffendingFieldSources(fields, pool) {
  * The narrowing pass's core relevance decision, isolated for direct
  * testing: every capture in `resolvedPool` — other than `primaryCapture`,
  * which must never be dropped — whose own top-level response JSON owns at
- * least one of `offendingFields`. This is the actual "is this capture
+ * least one of `offendingFields`, PLUS any other same-host capture whose
+ * path is in the same structural family ({@link isSamePathFamily}) as one
+ * of those field-owning captures. This is the actual "is this capture
  * structurally part of the resolved chain or incidental noise" call;
  * {@link healUnreferencedUrlFieldsOnce} only wires it into the regenerate
  * retry loop.
  *
+ * The family-broadening step exists because a noise endpoint's alternate
+ * path/query-string variant (e.g. a `/default` GET variant of a POST the
+ * field check already caught) commonly carries none of the fields that
+ * flagged its sibling — it is caught by structural isolation alone, the
+ * same signal {@link isStructurallyIsolatedCapture} uses for pool-relative
+ * isolation, generalized here to "related to an already-known noise path"
+ * rather than "isolated from the whole pool". Without it, that variant
+ * survives to the emitted contract as its own hard-coded call, requiring a
+ * required-URL-field trigger of its own it may never have.
+ *
  * Exported for tests: this predicate decides which captures the required-
  * URL-field guard's self-heal excludes before regenerating.
  */
@@ -8485,6 +8615,19 @@ function identifyNoiseCapturesForFields(offendingFields, resolvedPool, primaryCa
                 noiseCaptures.add(capture);
         }
     }
+    const noiseUrls = [...noiseCaptures].map((capture) => ({
+        path: safeUrlPathname(capture.url),
+        hostname: captureHostname(capture.url),
+    }));
+    for (const { capture } of resolvedPool) {
+        if (capture === primaryCapture || noiseCaptures.has(capture))
+            continue;
+        const path = safeUrlPathname(capture.url);
+        const hostname = captureHostname(capture.url);
+        const isSameHostFamilyMatch = noiseUrls.some((noise) => noise.hostname === hostname && (0, capture_filters_1.isSamePathFamily)(path, noise.path));
+        if (isSameHostFamilyMatch)
+            noiseCaptures.add(capture);
+    }
     return noiseCaptures;
 }
 /**
@@ -8822,7 +8965,7 @@ async function main() {
         // heuristic extraction finds.
         const unfilteredHeuristicActionCaptures = gql
             ? dedupRedundantSameOperationCaptures(graphqlActionSequence, primaryGraphQLOperation)
-            : collapseRedundantPatches(extractActionSequence(activeCaptures, null, foldReturnSpec, ownBackendHostnames, fallbackDomain));
+            : collapseRedundantSameEndpointCaptures(collapseRedundantPatches(extractActionSequence(activeCaptures, null, foldReturnSpec, ownBackendHostnames, fallbackDomain)));
         // A flow-declared submitEndpointPattern is authoritative: it may match only
         // the final step's URL (the natural way to describe "the button that
         // finishes the wizard") even though the earlier steps of the same chain