@enricai/barnacle 1.12.64 → 1.12.66

package/dist/scripts/recon-generate.js

@@ -4493,7 +4493,15 @@ function replaceGuardedAgainstExistingPlaceholders(text, pattern, bindingByValue
  * first, and the literal is gone by the time the KV pass runs — masking
  * payload precedence on every call after the one that scraped it.
  */
-function interpolateStateValues(template, priorSteps, targetCapture, payloadAccessorByValue = new Map(), isJsonBody = false, producerBoundaryBindings = new Map(), stepIndex = -1, topLevelPayloadKvValues = new Set()) {
+function interpolateStateValues(template, priorSteps, targetCapture, payloadAccessorByValue = new Map(), isJsonBody = false, producerBoundaryBindings = new Map(), stepIndex = -1, topLevelPayloadKvValues = new Set(), 
+// A fold target's own join-field value (see `joinFieldValuesByStep` in
+// `emitMultiStepExecuteHttp`) must stay a literal here — binding it to a
+// prior step's produced state var (e.g. `${productId}`, always the FIRST
+// primary item's value) freezes every per-item drill call onto that one
+// item; the fold loop's own later `parameterize` pass is what rebinds the
+// literal to `${item.<field>}` per iteration, but only if the literal
+// text survives this pass untouched.
+excludedJoinFieldValues = new Set()) {
     const stateBindings = deriveStateVarByValue(priorSteps, targetCapture);
     const bindingByValue = new Map();
     for (const [value, accessor] of payloadAccessorByValue) {
@@ -4508,6 +4516,8 @@ function interpolateStateValues(template, priorSteps, targetCapture, payloadAcce
             continue;
         if (topLevelPayloadKvValues.has(value) && !isProducerStep)
             continue;
+        if (excludedJoinFieldValues.has(value) && !isProducerStep)
+            continue;
         bindingByValue.set(value, `\${${binding.varName}}`);
         sourceNameByValue.set(value, binding.sourceName);
         if (binding.restricted)
@@ -5525,7 +5535,7 @@ pascalName = null) {
         // length/chain-eligibility scoping doesn't happen to catch the coincidence.
         const url = (0, capture_filters_1.isZeroVarianceRepeatCapture)(cap, actions.map((a) => a.capture))
             ? cap.url
-            : interpolateStateValues(cap.url, prior, cap, payloadAccessorByValue, false, producerBoundaryBindings, i);
+            : interpolateStateValues(cap.url, prior, cap, payloadAccessorByValue, false, producerBoundaryBindings, i, new Set(), joinFieldValuesByStep.get(i) ?? new Set());
         // Form-schema substitution runs first on the raw recon body so its
         // field-id-anchored matches see the original JSON. State-threading and
         // payload key-value passes then run on top. Option-id substitution runs
@@ -5595,7 +5605,7 @@ pascalName = null) {
             ? applyUrlParamPayloadSubstitutions(rawBodyWithProducerBoundary, parsedBody, urlParamBindings)
             : rawBodyWithProducerBoundary;
         const bodyAfterStateAndKv = rawBodyWithUrlParams
-            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies)
+            ? applyPayloadKeyValueSubstitutions(interpolateStateValues(rawBodyWithUrlParams, prior, cap, payloadAccessorByValue, true, producerBoundaryBindings, i, topLevelPayloadKvValues, joinFieldValuesByStep.get(i) ?? new Set()), inputBody, additionalBodies, outDiscoveredAdditionalBodyKeys, allResponseBodies)
             : "";
         // Mechanism A — generic (plain-JSON, wire-key-anchored) dropdown label→code
         // rewrite. Runs AFTER interpolateStateValues + the payload-KV pass, not
@@ -7885,6 +7895,60 @@ function readValueAtPath(body, path) {
         return node[segment];
     }, body);
 }
+/**
+ * Turns a flow author's plain dot-separated {@link FoldReturnSpec.resultsPath}
+ * / `drillResultsPath` into the SAME {@link ARRAY_WILDCARD_SEGMENT}-bearing
+ * shape {@link findAllObjectArrayFields} would have discovered structurally,
+ * by walking `rawSegments` against a REAL `body` and inserting the sentinel
+ * wherever the path crosses an array the author's segment doesn't literally
+ * index into. A JSON dot-path is ordinary object-property notation; it has
+ * no convention of its own for "every element of this array" (that spelling
+ * is this module's internal detail), so an author naming a genuinely nested
+ * per-ancestor array — e.g. `"trips.legs"` for a response shaped
+ * `{ trips: [{ legs: [...] }] }` — always omits it. Left unresolved, that
+ * mismatch is silent and total: `objectItemsAtPath`'s plain (no-wildcard)
+ * branch reads a property straight off the array object, resolves to
+ * `undefined`, and the whole spec fails to match ANY primary — and even
+ * where a structural target already exists to fall back onto, every
+ * primaryArrayPath equality check the fold-join merge (
+ * {@link mergeSpecPlanOntoSamePrimary}) runs is a bare `JSON.stringify`
+ * comparison against the structural path's own always-wildcarded form, so a
+ * declared path that's semantically identical but spelled without the
+ * sentinel can never match it either — the structural guess silently wins
+ * regardless of how many per-target override branches are added. Normalizing
+ * at the one point every one of those comparisons ultimately reads from
+ * fixes them all at once, rather than teaching each comparison site its own
+ * tolerance.
+ *
+ * A literal numeric segment (see {@link ARRAY_INDEX_KEY_PATTERN}) is
+ * left as-is — an author who names one exact array element that way already
+ * resolves correctly via `readValueAtPath`'s ordinary bracket access, and
+ * rewriting it to the wildcard would silently widen "this one element" into
+ * "every element". Uses the array's own first object-array item as the
+ * representative to keep walking deeper (mirroring
+ * {@link findAllObjectArrayFieldsUncached}'s own DFS-first-match precedent);
+ * a path that turns out to disagree across sibling elements is exactly what
+ * {@link objectItemsAtPath}'s later wildcard-driven `.flatMap` — not this
+ * one-shot shape walk — is responsible for reconciling.
+ */
+function resolveDeclaredArrayPath(rawSegments, body) {
+    const resolved = [];
+    let node = body;
+    for (const segment of rawSegments) {
+        if (Array.isArray(node) &&
+            segment !== ARRAY_WILDCARD_SEGMENT &&
+            !ARRAY_INDEX_KEY_PATTERN.test(segment)) {
+            resolved.push(ARRAY_WILDCARD_SEGMENT);
+            node = node.find(isObjectArrayItem);
+        }
+        resolved.push(segment);
+        node =
+            node !== null && typeof node === "object"
+                ? node[segment]
+                : undefined;
+    }
+    return resolved;
+}
 /** The object items of the array at `path` — the same subset
  * {@link findObjectArrayField} exposes as `items`, but anchored to a
  * caller-supplied path instead of discovered by DFS. `null` when `path`
@@ -8184,14 +8248,33 @@ function compileFoldReturnEndpointMatcher(spec) {
 function compileFoldReturnResultsMatcher(spec) {
     if (spec === null)
         return () => false;
-    const resultsPath = spec.resultsPath.split(".");
-    return (capture) => objectItemsAtPath(capture.responseBody, resultsPath) !== null;
+    const rawResultsPath = spec.resultsPath.split(".");
+    return (capture) => objectItemsAtPath(capture.responseBody, resolveDeclaredArrayPath(rawResultsPath, capture.responseBody)) !== null;
 }
 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(".");
+primaryIdentityAnchor = null, 
+// When given, restricts the loop to this ONE primaryStepIndex instead of
+// scanning every occurrence and keeping only the freshest. Used by
+// mergeSpecPlanOntoSamePrimary to resolve a declared joinFields override
+// independently for EACH re-issued/paginated primary occurrence, since the
+// freshest-wins scan below only ever resolves the LAST occurrence.
+exactPrimaryStepIndex = null, 
+// When given, restricts the matching-drill scan below to candidates whose
+// OWN endpoint (not a later chain hop) matches this key. A single primary
+// occurrence can structurally resolve MULTIPLE independent per-item
+// targets — one per distinct drill endpoint (e.g. a genuinely per-item
+// drill loop where each item's own request lands on the SAME endpoint
+// pattern but a distinct path/endpoint identity) — and this function's own
+// freshest-first scan below `break`s after the FIRST endpoint it resolves,
+// so an unrestricted call can only ever return an override for ONE of
+// them. Used by mergeSpecPlanOntoSamePrimary to resolve the declared
+// joinFields override independently for EACH structural target, keyed by
+// its own drill endpoint, instead of only the one this function's
+// freshest-first scan happens to land on first.
+restrictToDrillEndpointKey = null) {
+    const rawPrimaryArrayPath = spec.resultsPath.split(".");
     const matchesFoldReturnEndpoint = compileFoldReturnEndpointMatcher(spec);
     // Built once and shared across every primaryStepIndex — see
     // buildRequestValueIndex's docstring. Lets each primary immediately tell
@@ -8201,10 +8284,14 @@ primaryIdentityAnchor = null) {
     const requestValueIndex = buildRequestValueIndex(actions);
     let freshestPlan = null;
     for (let primaryStepIndex = 0; primaryStepIndex < actions.length; primaryStepIndex++) {
+        if (exactPrimaryStepIndex !== null && primaryStepIndex !== exactPrimaryStepIndex) {
+            continue;
+        }
         if (primaryIdentityAnchor !== null &&
             operationGroupKey(actions[primaryStepIndex].capture) !== primaryIdentityAnchor) {
             continue;
         }
+        const primaryArrayPath = resolveDeclaredArrayPath(rawPrimaryArrayPath, actions[primaryStepIndex].capture.responseBody);
         const primaryItems = objectItemsAtPath(actions[primaryStepIndex].capture.responseBody, primaryArrayPath);
         if (!primaryItems)
             continue;
@@ -8229,7 +8316,9 @@ primaryIdentityAnchor = null) {
         // response-only fallback below exists to resolve.
         const matchingDrillStepIndices = [];
         for (let drillStepIndex = primaryStepIndex + 1; drillStepIndex < actions.length; drillStepIndex++) {
-            if (matchesFoldReturnEndpoint(actions[drillStepIndex].capture)) {
+            if (matchesFoldReturnEndpoint(actions[drillStepIndex].capture) &&
+                (restrictToDrillEndpointKey === null ||
+                    endpointKey(actions[drillStepIndex].capture.url) === restrictToDrillEndpointKey)) {
                 matchingDrillStepIndices.push(drillStepIndex);
             }
         }
@@ -8291,7 +8380,7 @@ primaryIdentityAnchor = null) {
                 if (spec.drillResultsPath === undefined) {
                     return findObjectArrayFieldOrWholeObject(drill.capture.responseBody)?.path ?? null;
                 }
-                const path = spec.drillResultsPath.split(".");
+                const path = resolveDeclaredArrayPath(spec.drillResultsPath.split("."), drill.capture.responseBody);
                 return objectItemsAtPath(drill.capture.responseBody, path) ? path : null;
             })();
             const { chain, chainArrayPath, chainTerminalIndex } = computeFoldChain(actions, entryIndex, drillArrayPath ?? []);
@@ -8363,6 +8452,26 @@ function isDescendantArrayPath(candidate, base) {
  * spec's own drill indices look independent, so the heuristic's wrong-level
  * guess never survives alongside the corrected one.
  */
+/**
+ * The stable identity of the logical drill-down a {@link FoldTarget}
+ * resolves onto: the endpoint of its chain's TERMINAL call (the response
+ * actually folded — see {@link FoldTarget.chainTerminalIndex}) paired with
+ * the specific array read off that response (see
+ * {@link FoldTarget.chainArrayPath}). Neither piece alone is stable enough to
+ * compare two independently-resolved targets by: `drillStepIndex` (the
+ * chain's ENTRY point) can legitimately differ between the structural
+ * heuristic's own request-threading resolution and a spec's
+ * response-only/upstream-hop resolution even when both terminate at the same
+ * call (see {@link buildFoldPlanFromSpec}'s `entryIndex` docstring); and the
+ * terminal endpoint alone can collide when one response happens to carry TWO
+ * unrelated per-item arrays for two entirely different primaries (e.g. a
+ * combined status response naming both `entries` and `contracts`). Pairing
+ * the terminal's endpoint with the specific array it reads disambiguates
+ * both cases at once.
+ */
+function foldTargetDrillIdentity(actions, target) {
+    return `${endpointKey(actions[target.chainTerminalIndex].capture.url)}\u0000${target.chainArrayPath.join(".")}`;
+}
 function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec, 
 // See detectDrillDownFoldPlan's identical parameter. Threaded into this
 // function's own buildFoldPlanFromSpec call so a spec plan resolved here
@@ -8371,9 +8480,82 @@ function mergeSpecPlanOntoSamePrimary(structuralPlans, actions, foldReturnSpec,
 primaryIdentityAnchor = null) {
     if (foldReturnSpec === null)
         return [...structuralPlans];
+    // Override joinFields on EVERY structural primary occurrence the spec can
+    // independently resolve at its OWN primaryStepIndex — not just whichever
+    // single occurrence the freshest-wins `specPlan` resolution below happens
+    // to land on. A re-issued/paginated primary (same endpoint, multiple
+    // captures) produces one independent structural plan per occurrence; each
+    // must get the declared override, not just the freshest one.
+    const structuralPlansWithPerOccurrenceOverrides = structuralPlans.map((plan) => {
+        // Resolved once per structural TARGET (keyed on that target's own drill
+        // endpoint), not once for the whole primary occurrence: buildFoldPlanFromSpec's
+        // freshest-first scan `break`s after the first drill endpoint it resolves, so a
+        // single unrestricted call can only ever produce an override for ONE of a
+        // primary's structural targets even when it has several (e.g. a genuinely
+        // per-item drill loop resolving one independent target per item, each at its
+        // own endpoint). See buildFoldPlanFromSpec's restrictToDrillEndpointKey docstring.
+        const matchesDeclaredEndpoint = compileFoldReturnEndpointMatcher(foldReturnSpec);
+        const declaredPrimaryArrayPath = resolveDeclaredArrayPath(foldReturnSpec.resultsPath.split("."), actions[plan.primaryStepIndex].capture.responseBody);
+        const mergedTargets = plan.targets.map((target) => {
+            const ownSpecPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor, plan.primaryStepIndex, endpointKey(actions[target.drillStepIndex].capture.url));
+            if (ownSpecPlan !== null &&
+                JSON.stringify(ownSpecPlan.primaryArrayPath) === JSON.stringify(plan.primaryArrayPath)) {
+                // ownSpecPlan was resolved with restrictToDrillEndpointKey pinned to
+                // this target's OWN drill endpoint, so its single target (see
+                // buildFoldPlanFromSpec's `targets: [{...}]` literal — it never
+                // returns more than one) IS the spec's resolution of this restricted
+                // endpoint by construction. Matching it back to `target` via
+                // foldTargetDrillIdentity is not just redundant but actively wrong: a
+                // multi-hop drill chain can make the spec's forward walk
+                // (buildFoldPlanFromSpec's computeFoldChain resolution) land on a
+                // different chainTerminalIndex/chainArrayPath than the structural
+                // heuristic did for the exact same restricted endpoint, so the
+                // identity lookup misses and the declared joinFields override is
+                // silently dropped in favor of the heuristic's structural guess.
+                const specTarget = ownSpecPlan.targets[0];
+                return specTarget === undefined ? target : { ...target, joinFields: specTarget.joinFields };
+            }
+            // buildFoldPlanFromSpec came back null (or landed on a different
+            // primaryArrayPath) because it couldn't resolve a
+            // primaryMatchedItemIndex for this drill — the join value it names
+            // sits on the drill response but isn't discoverable at that same
+            // literal path on any primary item (a generation-time-only schema-
+            // inference concern; see resolveSpecMatchedPrimaryItemIndexFromResponse).
+            // That failure has nothing to do with whether the declared joinFields
+            // should be trusted at RUNTIME: emitFoldMatchAndMergeLines only ever
+            // reads target.joinFields (a field-name string), never
+            // primaryMatchedItemIndex. Once the declared spec's own endpoint
+            // pattern and resultsPath demonstrably match THIS already
+            // structurally-resolved target, the declared joinFields must win over
+            // the structural guess regardless of whether a representative item
+            // could be picked.
+            // Test against the chain's TERMINAL capture (where the fold array —
+            // and thus the declared identifier field — actually lives), not the
+            // structural heuristic's threading-entry `drillStepIndex`: on a
+            // multi-hop chain the two can diverge (see foldTargetDrillIdentity's
+            // docstring above), and a declared endpointPattern names the call
+            // that holds the array, not whichever earlier hop some other field
+            // happened to be threaded into.
+            const targetMatchesDeclaredEndpoint = matchesDeclaredEndpoint(actions[target.chainTerminalIndex].capture);
+            const primaryArrayPathMatchesSpec = JSON.stringify(declaredPrimaryArrayPath) === JSON.stringify(plan.primaryArrayPath);
+            return targetMatchesDeclaredEndpoint && primaryArrayPathMatchesSpec
+                ? { ...target, joinFields: foldReturnSpec.joinFields }
+                : target;
+        });
+        // A spec-declared target the heuristic missed entirely (an independent
+        // drill-down at a NEW endpoint) is still found via the original
+        // unrestricted resolution, which is free to land on any endpoint.
+        const ownSpecPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor, plan.primaryStepIndex);
+        const existingDrillIdentities = new Set(plan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+        const newTargets = ownSpecPlan !== null &&
+            JSON.stringify(ownSpecPlan.primaryArrayPath) === JSON.stringify(plan.primaryArrayPath)
+            ? ownSpecPlan.targets.filter((target) => !existingDrillIdentities.has(foldTargetDrillIdentity(actions, target)))
+            : [];
+        return { ...plan, targets: [...mergedTargets, ...newTargets] };
+    });
     const specPlan = buildFoldPlanFromSpec(actions, foldReturnSpec, primaryIdentityAnchor);
     if (specPlan === null)
-        return [...structuralPlans];
+        return structuralPlansWithPerOccurrenceOverrides;
     const specPrimaryEndpointKey = endpointKey(actions[specPlan.primaryStepIndex].capture.url);
     // Deliberately keyed on the RAW primaryStepIndex (not endpoint identity):
     // this branch trusts the structural target's own chain/drillArrayPath and
@@ -8383,7 +8565,7 @@ primaryIdentityAnchor = null) {
     // different index) may have matched a different item entirely, so it must
     // fall through to the wholesale-replace (sharedDrillPlan) or union
     // (consumedPrimarySteps) handling below instead of merging by identity.
-    const samePrimaryPlan = structuralPlans.find((plan) => plan.primaryStepIndex === specPlan.primaryStepIndex &&
+    const samePrimaryPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => plan.primaryStepIndex === specPlan.primaryStepIndex &&
         JSON.stringify(plan.primaryArrayPath) === JSON.stringify(specPlan.primaryArrayPath));
     if (samePrimaryPlan !== undefined) {
         // A structural target serving the SAME drill-down the spec declares
@@ -8403,38 +8585,53 @@ primaryIdentityAnchor = null) {
         // but equally valid, occurrence of the SAME re-issued/paginated drill
         // endpoint — raw-index equality only happened to override when both
         // resolutions picked the identical occurrence, silently leaving every
-        // other occurrence's joinFields un-overridden.
-        const specTargetsByDrillEndpointKey = new Map(specPlan.targets.map((target) => [
-            endpointKey(actions[target.drillStepIndex].capture.url),
-            target,
-        ]));
-        return structuralPlans.map((plan) => {
+        // other occurrence's joinFields un-overridden. Keyed on each target's
+        // {@link foldTargetDrillIdentity} — the terminal endpoint paired with the
+        // specific array it reads — rather than `drillStepIndex`: a spec's
+        // declared join value often resolves only through an upstream entry hop
+        // (e.g. a header-threaded token) that isn't the endpointPattern-matched
+        // call itself, so its `drillStepIndex` (== that entry hop) can
+        // legitimately differ from the structural heuristic's own
+        // `drillStepIndex` (its own, possibly different, threading entry point)
+        // even when both chains terminate at the exact same logical drill-down
+        // call and array.
+        const specTargetsByDrillIdentity = new Map(specPlan.targets.map((target) => [foldTargetDrillIdentity(actions, target), target]));
+        return structuralPlansWithPerOccurrenceOverrides.map((plan) => {
             if (plan !== samePrimaryPlan)
                 return plan;
             const mergedTargets = plan.targets.map((target) => {
-                const specTarget = specTargetsByDrillEndpointKey.get(endpointKey(actions[target.drillStepIndex].capture.url));
+                const specTarget = specTargetsByDrillIdentity.get(foldTargetDrillIdentity(actions, target));
                 return specTarget === undefined ? target : { ...target, joinFields: specTarget.joinFields };
             });
-            const existingDrillEndpointKeys = new Set(plan.targets.map((target) => endpointKey(actions[target.drillStepIndex].capture.url)));
-            const newTargets = specPlan.targets.filter((target) => !existingDrillEndpointKeys.has(endpointKey(actions[target.drillStepIndex].capture.url)));
+            const existingDrillIdentities = new Set(plan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+            const newTargets = specPlan.targets.filter((target) => !existingDrillIdentities.has(foldTargetDrillIdentity(actions, target)));
             return { ...plan, targets: [...mergedTargets, ...newTargets] };
         });
     }
     // No exact (primaryStepIndex, primaryArrayPath) match, but a structural
     // plan on the SAME primaryStepIndex may still have independently detected
-    // a target at the SAME drillStepIndex a spec target names — just at the
-    // wrong array level (e.g. a shallower structural guess that happens to
-    // share the spec's drill-down call). That structural target's own
-    // primaryArrayPath/drillArrayPath/joinFields describe the heuristic's
-    // guess, not the flow author's declaration, so the spec target replaces
-    // it wholesale rather than being discarded by the mismatched-array-path
-    // branch below or partially merged as if the array level matched.
-    const specDrillStepIndices = new Set(specPlan.targets.map((target) => target.drillStepIndex));
-    const sharedDrillPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
-        plan.targets.some((target) => specDrillStepIndices.has(target.drillStepIndex)));
+    // a target at the SAME drill ENDPOINT+array a spec target names — just at
+    // the wrong array level (e.g. a shallower structural guess that happens to
+    // share the spec's drill-down call). Matched by {@link
+    // foldTargetDrillIdentity} (see the samePrimaryPlan branch above for why
+    // the terminal+array, not the entry `drillStepIndex` alone, is the stable
+    // identity to compare on) — not raw drillStepIndex equality:
+    // buildFoldPlanFromSpec's own entryIndex resolution and the structural
+    // heuristic's request-threading scan can each land on a different, but
+    // equally valid, occurrence/hop of the SAME endpoint (or the same single
+    // occurrence reached via a different chain entry point), and raw-index
+    // equality only happens to hold when both resolutions pick the identical
+    // index. That structural target's own primaryArrayPath/drillArrayPath/
+    // joinFields describe the heuristic's guess, not the flow author's
+    // declaration, so the spec target replaces it wholesale rather than being
+    // discarded by the mismatched-array-path branch below or partially merged
+    // as if the array level matched.
+    const specDrillIdentities = new Set(specPlan.targets.map((target) => foldTargetDrillIdentity(actions, target)));
+    const sharedDrillPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+        plan.targets.some((target) => specDrillIdentities.has(foldTargetDrillIdentity(actions, target))));
     if (sharedDrillPlan !== undefined) {
-        const remainingTargets = sharedDrillPlan.targets.filter((target) => !specDrillStepIndices.has(target.drillStepIndex));
-        const otherPlans = structuralPlans.filter((plan) => plan !== sharedDrillPlan);
+        const remainingTargets = sharedDrillPlan.targets.filter((target) => !specDrillIdentities.has(foldTargetDrillIdentity(actions, target)));
+        const otherPlans = structuralPlansWithPerOccurrenceOverrides.filter((plan) => plan !== sharedDrillPlan);
         const keptStructuralPlans = remainingTargets.length === 0
             ? otherPlans
             : [...otherPlans, { ...sharedDrillPlan, targets: remainingTargets }];
@@ -8449,10 +8646,13 @@ primaryIdentityAnchor = null) {
     // the independence guard below would otherwise do, since a
     // level-correcting spec's own drill indices can look entirely
     // independent) or silently dropped by the mismatched-array-path checks.
-    const supersededShallowerPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+    const supersededShallowerPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
         isDescendantArrayPath(specPlan.primaryArrayPath, plan.primaryArrayPath));
     if (supersededShallowerPlan !== undefined) {
-        return [...structuralPlans.filter((plan) => plan !== supersededShallowerPlan), specPlan];
+        return [
+            ...structuralPlansWithPerOccurrenceOverrides.filter((plan) => plan !== supersededShallowerPlan),
+            specPlan,
+        ];
     }
     // Keyed by the (primaryStepIndex, primaryArrayPath) pair, not
     // primaryStepIndex alone — a structural plan only ever consumed ITS OWN
@@ -8469,7 +8669,7 @@ primaryIdentityAnchor = null) {
     // contends for.
     const consumedIndices = new Set();
     const consumedPrimarySteps = new Set();
-    for (const plan of structuralPlans) {
+    for (const plan of structuralPlansWithPerOccurrenceOverrides) {
         const planPrimaryEndpointKey = endpointKey(actions[plan.primaryStepIndex].capture.url);
         consumedPrimarySteps.add(`${planPrimaryEndpointKey}:${JSON.stringify(plan.primaryArrayPath)}`);
         for (const target of plan.targets) {
@@ -8480,19 +8680,27 @@ primaryIdentityAnchor = null) {
         !consumedPrimarySteps.has(`${specPrimaryEndpointKey}:${JSON.stringify(specPlan.primaryArrayPath)}`) &&
         specPlan.targets.every((target) => target.chain.every((chainIndex) => !consumedIndices.has(chainIndex)));
     if (specConsumesOnlyItsOwnIndices)
-        return [...structuralPlans, specPlan];
+        return [...structuralPlansWithPerOccurrenceOverrides, specPlan];
     // The spec's primary endpoint/array is already consumed by a structural
     // plan on a DIFFERENT capture of the same re-issued primary operation
     // (paginated primary), but its own target chains touch no index that plan
     // already depends on — this is the same identity, not a raw-index
     // coincidence, so union the spec's targets onto it rather than silently
-    // dropping a declaration the flow author explicitly wrote.
-    const sameIdentityPlan = structuralPlans.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
+    // dropping a declaration the flow author explicitly wrote. Membership in
+    // "already covered" is decided by {@link foldTargetDrillIdentity} (see the
+    // samePrimaryPlan branch above for why the terminal+array, not the entry
+    // `drillStepIndex` alone, is the stable identity) — not raw drillStepIndex
+    // equality. A spec target sharing a structural target's drill identity is
+    // a re-declaration of that SAME drill-down (handled as a wholesale replace
+    // by sharedDrillPlan above), not an independent one to union — so this
+    // only ever unions genuinely new endpoints onto an already-identified
+    // primary.
+    const sameIdentityPlan = structuralPlansWithPerOccurrenceOverrides.find((plan) => endpointKey(actions[plan.primaryStepIndex].capture.url) === specPrimaryEndpointKey &&
         JSON.stringify(plan.primaryArrayPath) === JSON.stringify(specPlan.primaryArrayPath) &&
-        specPlan.targets.every((target) => !plan.targets.some((t) => t.drillStepIndex === target.drillStepIndex)));
+        specPlan.targets.every((target) => !plan.targets.some((t) => foldTargetDrillIdentity(actions, t) === foldTargetDrillIdentity(actions, target))));
     if (sameIdentityPlan === undefined)
-        return [...structuralPlans];
-    return structuralPlans.map((plan) => plan === sameIdentityPlan ? { ...plan, targets: [...plan.targets, ...specPlan.targets] } : plan);
+        return [...structuralPlansWithPerOccurrenceOverrides];
+    return structuralPlansWithPerOccurrenceOverrides.map((plan) => plan === sameIdentityPlan ? { ...plan, targets: [...plan.targets, ...specPlan.targets] } : plan);
 }
 /**
  * The single fold-plan entry point: {@link detectDrillDownFoldPlan}'s