Charcoal, 116 105 bytes

32 26 bytes of code are shared between the two programs, although I'm currently counting this separately for each program:

⊞υＥ⊕η¬ιＦ⊖θ⊞υＥ⊕ηΣ✂…§υι⊕κ±⊕ζ 

Explanation:

⊞υＥ⊕η¬ι 

Start with a list of a 1 followed by s 0s. This represents the count of arrays of length 0 with sums of 0 to s.

Ｆ⊖θ 

Extend the list of lists up to arrays of length l-1.

⊞υＥ⊕ηΣ✂…§υι⊕κ±⊕ζ 

For each sum of 0 to s calculate the number of arrays with that sum.

63 57 bytes for unrank:

⊞υＥ⊕η¬ιＦ⊖θ⊞υＥ⊕ηΣ✂…§υι⊕κ±⊕ζＦ⮌υ«≔⁰δＷ¬›§ιηε«≧⁻§ιηε≦⊖η≦⊕δ»⟦Ｉδ 

Try it online! Link is to verbose version of code. Explanation:

Ｆ⮌υ« 

Loop over each element.

≔⁰δ 

Start with a current element of zero.

Ｗ¬›§ιηε« 

Repeat while there are still sufficient counts of shorter arrays:

≧⁻§ιηε 

Subtract the count from the rank.

≦⊖η 

Decrement the remaining sum.

≦⊕δ 

Increment the current element.

»⟦Ｉδ 

Output the current element.

53 48 bytes for rank:

⊞υＥ⊕η¬ιＦ⊖θ⊞υＥ⊕ηΣ✂…§υι⊕κ±⊕ζＰＩΣＥε↨¹Ｅ駧⮌υκ⁻Σ✂εκθ¹λ 

Try it online! Link is to verbose version of code. Explanation:

ＰＩΣＥε↨¹Ｅ駧⮌υκ⁻Σ✂εκθ¹λ 

For each element in the array to rank, get the count of arrays of the remaining length with sums of between the remaining sum including and excluding the current element.

It's possible to replace the shared code with a 51 byte version that reduces the time complexity by using a sliding window to calculate the counts of arrays with specific lengths and sums.

≔Ｅ⊕η¬ιτＦθ«⊞υτ≔⟦⟧σ≔⁰δＦ⊕η«≧⁺§τκδ⊞σ먪‹κζ≧⁻§τ⁻κζδ»≔στ»Ｆ⮌υ«≔⁰δＷ¬›§ιηε«≧⁻§ιηε≦⊖η≦⊕δ»⟦Ｉδ 

Try it online! Link is to verbose version of code.

≔Ｅ⊕η¬ιτＦθ«⊞υτ≔⟦⟧σ≔⁰δＦ⊕η«≧⁺§τκδ⊞σ먪‹κζ≧⁻§τ⁻κζδ»≔στ»ＰＩΣＥε↨¹Ｅ駧⮌υκ⁻Σ✂εκθ¹λ 

Try it online! Link is to verbose version of code.

Python 3, 326,334 bytes (+8 to fix complexity @Bubbler)

def P(l,m,s,o): *r,o=0,o+m*o[-1:] for y,z in zip(o[:s+1],-~m*[0]+o):r[len(r):]=r[-1]+y-z, return l*o and P(l-1,m,s,r[1:])+[o] def R(p,L): l,m,s=p;T=P(*p,[1,1]);r=0 for t,l in zip(T,L):r+=t[s]-t[s-l];s-=l return r def U(p,r): l,m,s,*L=p;T=P(*p,[1,0]) for t in T: j=m	 while(t[s]<=r)*j:r-=t[s];s-=1;j-=1 L+=[m-j] return L 

Try it online!

Old version

Doesn't feel very short, but maybe a byte count of "only" 3x the golfy languages is acceptable.

If I'm not mistaken, both R and U are O(lm).**Nonsense!**O(ls) using @Bubbler's suggestion.

The function P creates generalised Pascal's triangles where new rows are generated by taking sums of m+1 elements of the current (m=1 in the original Pascal's triangle). Generalising binomial coefficients which count sums made out a total of of l-s 0s and s 1s, the entries of the generalised triangles count sums of 0s,1s,...,ms with l terms and sum s.

Implementation notes: The output contains a few padding elements on the right end for convenience. By passing [1,0] or [1,1] for o we can choose between the plain triangle (used by U) or the partial row sums (used by R). To limit complexity we calculate only the first s+1 terms in every row.

Pari/GP, 142 bytes

r(l,s,m,a)=y=x^m++\(x-1);sum(i=1,l,t=a[i];polcoef(y%x^t*y^(l-i),t+s-=t)) u(l,s,m,q)=a=vector(l);for(i=1,l,until(r(l,s,m,a)>q,a[i]++);a[i]--);a 

Try it online!

The rank is 0-indexed.