fix: scan top-down for effective base in all resolvers

Change base-finding to scan from highest priority downward to find the
nearest replace layer, then compose only layers above it. Prevents
evaluation of irrelevant lower layers (e.g. a wrap without placeholder
below a higher-priority replace) across Python, bash, and PowerShell.

Author: mnriem

scripts/bash/common.sh

@@ -537,19 +537,13 @@ except Exception:
         return 0
     fi
 
-    # Compose bottom-up: start from the effective base.
-    # Find the highest-priority replace layer that sits below composing layers.
-    # Skip non-replace layers below any replace (they have no base to compose onto).
-    local content=""
-    local has_base=false
+    # Find the effective base: scan from highest priority (index 0) downward
+    # to find the nearest replace layer. Only compose layers above that base.
     local base_idx=-1
     local i
-    for (( i=count-1; i>=0; i-- )); do
-        local strat="${layer_strategies[$i]}"
-        if [ "$strat" = "replace" ]; then
+    for (( i=0; i<count; i++ )); do
+        if [ "${layer_strategies[$i]}" = "replace" ]; then
             base_idx=$i
-        elif [ $base_idx -ge 0 ]; then
-            # Found a non-replace above a replace — this is where composition starts
             break
         fi
     done
@@ -558,7 +552,8 @@ except Exception:
         return 1  # no base layer found
     fi
 
-    # Read the base content; start composing from the layer above the base
+    # Read the base content; compose layers above the base (higher priority)
+    local content
     content=$(cat "${layer_paths[$base_idx]}"; printf x)
     content="${content%x}"
 

scripts/powershell/common.ps1

@@ -532,15 +532,13 @@ except Exception:
         return (Get-Content $layerPaths[0] -Raw)
     }
 
-    # Find the effective base: highest-priority replace below composing layers.
-    # Skip non-replace layers below any replace (they have no base to compose onto).
+    # Find the effective base: scan from highest priority (index 0) downward
+    # to find the nearest replace layer. Only compose layers above that base.
     $baseIdx = -1
-    for ($i = $layerPaths.Count - 1; $i -ge 0; $i--) {
-        $strat = $layerStrategies[$i]
-        if ($strat -eq 'replace') {
+    for ($i = 0; $i -lt $layerPaths.Count; $i++) {
+        if ($layerStrategies[$i] -eq 'replace') {
             $baseIdx = $i
-        } elseif ($baseIdx -ge 0) {
-            break  # non-replace above a replace — composition starts here
+            break
         }
     }
     if ($baseIdx -lt 0) { return $null }

src/specify_cli/presets.py

@@ -2920,24 +2920,24 @@ def resolve_content(
         # layers is ordered highest-priority first. We process in reverse.
         reversed_layers = list(reversed(layers))
 
-        # Find the base content: scan bottom-up for the highest-priority
-        # "replace" layer that can serve as a base. Non-replace layers below
-        # the base are irrelevant (they have nothing to compose onto).
-        content = None
-        start_idx = 0
-        for i, layer in enumerate(reversed_layers):
+        # Find the effective base: scan from highest priority (layers[0]) downward
+        # to find the nearest replace layer. Only compose layers above that base.
+        # layers is highest-priority first; reversed_layers is lowest first.
+        base_layer_idx = None  # index in layers[] (highest-priority first)
+        for idx, layer in enumerate(layers):
             if layer["strategy"] == "replace":
-                content = layer["path"].read_text(encoding="utf-8")
-                start_idx = i + 1
-            elif content is not None:
-                # Found a non-replace layer above a replace — stop scanning.
-                # The replace layer(s) form the base; composition starts here.
+                base_layer_idx = idx
                 break
-            # Non-replace layers below any replace are skipped (no base yet)
 
-        # If no base content found, there's nothing to compose onto
-        if content is None:
-            return None
+        if base_layer_idx is None:
+            return None  # no replace base found
+
+        # Convert to reversed_layers index
+        base_reversed_idx = len(layers) - 1 - base_layer_idx
+        content = layers[base_layer_idx]["path"].read_text(encoding="utf-8")
+        # Compose only the layers above the base (higher priority = lower index in layers,
+        # higher index in reversed_layers). Process bottom-up from base+1.
+        start_idx = base_reversed_idx + 1
 
         # For command composition, strip frontmatter from each layer to avoid
         # leaking YAML metadata into the composed body. The highest-priority