@flemist/test-variants 3.0.2 → 3.0.3

package/dist/bundle/browser.js

@@ -83,50 +83,50 @@ return l.sent(),[4,i.promises.writeFile(t,r,"utf-8")]
 ;case 2:return l.sent(),[2]}})})}function v(e,t){
 return e<t}class g{
 constructor({objectPool:e,lessThanFunc:t}={}){
-this._size=0,this._root=null,this.merge=_,
-this.collapse=y,this._objectPool=e,this._lessThanFunc=t||v
+this._size=0,this._root=null,this.merge=p,
+this.collapse=_,this._objectPool=e,this._lessThanFunc=t||v
 }clear(){this._root=null,this._size=0}get size(){
 return this._size}add(e){
 let t=null!=this._objectPool?this._objectPool.get():null
 ;return null==t?t={child:null,next:null,prev:null,
 item:e
-}:t.item=e,this._size++,this._root=_(this._root,t,this._lessThanFunc),t
+}:t.item=e,this._size++,this._root=p(this._root,t,this._lessThanFunc),t
 }getMin(){const{_root:e}=this
 ;return null==e?void 0:e.item}getMinNode(){
 return this._root}deleteMin(){const{_root:e}=this
 ;if(null==e)return;const t=e.item
 ;return this.delete(e),t}delete(e){var t
-;if(e===this._root)this._root=y(e.child,this._lessThanFunc);else{
+;if(e===this._root)this._root=_(e.child,this._lessThanFunc);else{
 if(null==e.prev){
 if(this._objectPool)throw new Error("The node is already deleted. Don't use the objectPool to prevent this error.")
 ;return}
 e.prev.child===e?e.prev.child=e.next:e.prev.next=e.next,null!=e.next&&(e.next.prev=e.prev),
-this._root=_(this._root,y(e.child,this._lessThanFunc),this._lessThanFunc)
+this._root=p(this._root,_(e.child,this._lessThanFunc),this._lessThanFunc)
 }
 e.child=null,e.prev=null,e.next=null,e.item=void 0,null===(t=this._objectPool)||void 0===t||t.release(e),
 this._size--}decreaseKey(e){
 e!==this._root&&(e.prev.child===e?e.prev.child=e.next:e.prev.next=e.next,
 null!=e.next&&(e.next.prev=e.prev),
-this._root=_(this._root,e,this._lessThanFunc))}
+this._root=p(this._root,e,this._lessThanFunc))}
 get isEmpty(){return null==this._root}
 [Symbol.iterator](){return this._iterate(!1)}
 nodes(){return{
 [Symbol.iterator]:()=>this._iterate(!0)}}
 _iterate(e){const t=this._lessThanFunc
 ;return function*n(r){
-r&&(e?yield r:yield r.item,r.child&&(null!=r.child.next&&(r.child=y(r.child,t),
+r&&(e?yield r:yield r.item,r.child&&(null!=r.child.next&&(r.child=_(r.child,t),
 r.child.prev=r),yield*n(r.child)))}(this._root)}}
-function _(e,t,n){let r,i
+function p(e,t,n){let r,i
 ;return null==e?t:null==t||e===t?e:(n(t.item,e.item)?(r=t,
 i=e):(r=e,i=t),i.next=r.child,
 null!=r.child&&(r.child.prev=i),i.prev=r,r.child=i,
-r.next=null,r.prev=null,r)}function y(e,t){
+r.next=null,r.prev=null,r)}function _(e,t){
 let n,r,i,s,o;if(null==e)return null
 ;for(s=e,n=null;null!=s;){
 if(r=s,i=r.next,null==i){r.prev=n,n=r;break}
-s=i.next,o=_(r,i,t),o.prev=n,n=o}
-for(o=null;null!=n;)s=n.prev,o=_(o,n,t),n=s
-;return o}function p(e,t){e(function(e){return{
+s=i.next,o=p(r,i,t),o.prev=n,n=o}
+for(o=null;null!=n;)s=n.prev,o=p(o,n,t),n=s
+;return o}function y(e,t){e(function(e){return{
 then(t,n){n(e)}}}(t))}function b(e){
 return null!=e&&"object"==typeof e&&"function"==typeof e.then
 }let m,x=[];function w(e){
@@ -200,7 +200,7 @@ const P=function(){};class k{constructor(e){
 if(this._status="pending",e&&e.aborted)this.promise=A.reject(e.reason),
 this.resolve=P,this.reject=P;else{let t,n
 ;if(this.promise=new Promise(function(e){
-t=e,n=function(t){p(e,t)}}),e){
+t=e,n=function(t){y(e,t)}}),e){
 const r=e.subscribe(function(e){n(e)})
 ;this.resolve=function(e){r(),t(e)
 },this.reject=function(e){r(),n(e)}
@@ -247,21 +247,21 @@ return i(e,t,n)});return"number"==typeof s?{
 iterationsAsync:0,iterationsSync:s
 }:null!==s&&"object"==typeof s?s:{
 iterationsAsync:0,iterationsSync:1}}catch(e){
-return i(e,t,n)}}}class F{constructor(e,t){
+return i(e,t,n)}}}class V{constructor(e,t){
 this._branch=null,this.order=e,this.parent=t}
 get branch(){if(!this._branch){
 const e=[this.order];let t=this.parent
 ;for(;null!=t;)e.push(t.order),t=t.parent
 ;this._branch=e}return this._branch}}
-function V(e){
+function F(e){
 return null!=e&&"object"==typeof e&&"function"==typeof e.then
-}let D,M=[];function C(e){
-M.push(e),D||(D=function(){
+}let M,D=[];function C(e){
+D.push(e),M||(M=function(){
 return l(this,void 0,void 0,function*(){
-for(;M.length>0;){yield 0;const e=M
-;M=[],e.forEach(e=>{try{e()}catch(e){
+for(;D.length>0;){yield 0;const e=D
+;D=[],e.forEach(e=>{try{e()}catch(e){
 console.error("Unhandled promise rejection",e)}})}
-D=null})}())}function R(e,t,n){C(()=>{try{
+M=null})}())}function R(e,t,n){C(()=>{try{
 const r=t?t(e):e;n._resolve(r)}catch(e){
 n._reject(e)}})}function q(e,t,n){C(()=>{if(t)try{
 const r=t(e);n._resolve(r)}catch(e){n._reject(e)
@@ -276,14 +276,14 @@ this.status="pending",this.value=void 0,this.reason=void 0,this._handlers=null
 },e(this._resolve,this._reject)}_resolve(e){
 "pending"===this.status&&(this.status="fulfilled",
 this._resolveAsync(e))}_resolveAsync(e){
-V(e)?e.then(this._resolveAsync,this._rejectAsync):this._resolveSync(e)
+F(e)?e.then(this._resolveAsync,this._rejectAsync):this._resolveSync(e)
 }_resolveSync(e){const t=this._handlers
 ;if(this.value=e,null!=t){this._handlers=null
 ;for(let n=0,r=t.length;n<r;n++){const[r,,i]=t[n]
 ;R(e,r,i)}}}_reject(e){
 "pending"===this.status&&this._rejectAsync(e)}
 _rejectAsync(e){
-this.status="rejected",V(e)?e.then(this._rejectAsync,this._rejectAsync):this._rejectSync(e)
+this.status="rejected",F(e)?e.then(this._rejectAsync,this._rejectAsync):this._rejectSync(e)
 }_rejectSync(e){const t=this._handlers
 ;if(this.reason=e,null!=t){this._handlers=null
 ;for(let n=0,r=t.length;n<r;n++){const[,r,i]=t[n]
@@ -292,9 +292,9 @@ this.status="rejected",V(e)?e.then(this._rejectAsync,this._rejectAsync):this._re
 this._handlers.push([e,t,n])):"fulfilled"===this.status?R(this.value,e,n):q(this.reason,t,n),
 n}catch(e){return this.then(void 0,e)}finally(e){
 const t=e&&function(t){const n=e()
-;return V(n)?n.then(()=>t):J.resolve(t)
+;return F(n)?n.then(()=>t):J.resolve(t)
 },n=e&&function(t){const n=e()
-;return V(n)?n.then(()=>J.reject(t)):J.reject(t)}
+;return F(n)?n.then(()=>J.reject(t)):J.reject(t)}
 ;return this.then(t,n)}static resolve(e){
 const t=new J(B);return t._resolve(e),t}
 static reject(e){const t=new J(B)
@@ -303,25 +303,25 @@ return"Promise"}static get[Symbol.species](){
 return J}static all(e){return function(e,t){
 let n,r;t||(t=Promise);const i=new t((e,t)=>{
 n=e,r=t});let s=e.length;const o=[]
-;return e.forEach((e,t)=>{V(e)?e.then(e=>{
+;return e.forEach((e,t)=>{F(e)?e.then(e=>{
 o[t]=e,0===--s&&n(o)},r):(o[t]=e,0===--s&&n(o))
 }),i}(e,J)}static allSettled(e){
 return function(e,t){let n;t||(t=Promise)
 ;const r=new t((e,t)=>{n=e});let i=e.length
 ;const s=[];return e.forEach((e,t)=>{
-V(e)?e.then(e=>{s[t]={status:"fulfilled",value:e
+F(e)?e.then(e=>{s[t]={status:"fulfilled",value:e
 },0===--i&&n(s)},e=>{s[t]={status:"rejected",
 reason:e},0===--i&&n(s)}):(s[t]={
 status:"fulfilled",value:e},0===--i&&n(s))}),r
 }(e,J)}static any(e){return function(e,t){let n,r
 ;t||(t=Promise);const i=new t((e,t)=>{n=e,r=t})
 ;let s=e.length;const o=[]
-;return e.forEach((e,t)=>{V(e)?e.then(n,e=>{
+;return e.forEach((e,t)=>{F(e)?e.then(n,e=>{
 o[t]=e,0===--s&&r(new AggregateError(o))}):n(e)
 }),i}(e,J)}static race(e){return function(e,t){
 let n,r;t||(t=Promise);const i=new t((e,t)=>{
 n=e,r=t});return e.forEach(e=>{
-V(e)?e.then(n,r):n(e)}),i}(e,J)}}
+F(e)?e.then(n,r):n(e)}),i}(e,J)}}
 const N=function(){};class ${constructor(e){
 if(this._status="pending",e&&e.aborted)this.promise=J.reject(e.reason),
 this.resolve=N,this.reject=N;else{let t,n
@@ -381,7 +381,7 @@ constructor(){this._queue=new g({lessThanFunc:W})}
 run(e,t,n){return this._run(!1,e,t,n)}
 runTask(e,t,n){return this._run(!0,e,t,n)}
 _run(e,t,n,r){const i=new $(r),s={
-priority:(o=Q++,l=n,null==o?null==l?null:l:new F(o,l)),
+priority:(o=Q++,l=n,null==o?null==l?null:l:new V(o,l)),
 func:t,abortSignal:r,resolve:i.resolve,
 reject:i.reject,readyToRun:!e};var o,l
 ;if(this._queue.add(s),e){const e=this;return{
@@ -423,8 +423,8 @@ const e=this._tickPromise
 tick(e){
 if(!(this._size>=this._maxSize))return this._tickPromise||(this._tickPromise=new k),
 function(e,t){return e?new Promise(function(n){
-if(e&&e.aborted)return void p(n,e.reason);let r,i
-;function s(e){i||(i=!0,r&&r(),p(n,e))}
+if(e&&e.aborted)return void y(n,e.reason);let r,i
+;function s(e){i||(i=!0,r&&r(),y(n,e))}
 t.then(function(e){r&&r(),n(e)
 }).catch(s),e&&(r=e.subscribe(s))}):t
 }(e,this._tickPromise.promise)}holdWait(e,t,n,r){
@@ -441,10 +441,10 @@ setTimeout(function(){t(e)},1)})
 ;if(t<60)return"".concat(t.toFixed(1),"s")
 ;var n=t/60
 ;return n<60?"".concat(n.toFixed(1),"m"):"".concat((n/60).toFixed(1),"h")
-}function ee(e,t,n){var r,i,o,v,g,_,y,p,m
+}function ee(e,t,n){var r,i,o,v,g,p,_,y,m
 ;return void 0===n&&(n={}),l(this,void 0,void 0,function(){
-var x,w,j,E,S,A,P,k,I,T,O,L,F,V,D,M,C,R,q,B,J,N,$,G,U,W,Q,K,H,ee,te,ne,re,ie,se,oe,le,ae,ce,ue,he,fe,de,ve,ge=this
-;return a(this,function(_e){switch(_e.label){
+var x,w,j,E,S,A,P,k,I,T,O,L,V,F,M,D,C,R,q,B,J,N,$,G,U,W,Q,K,H,ee,te,ne,re,ie,se,oe,le,ae,ce,ue,he,fe,de,ve,ge=this
+;return a(this,function(pe){switch(pe.label){
 case 0:
 return x=n.saveErrorVariants,w=null!==(r=null==x?void 0:x.retriesPerVariant)&&void 0!==r?r:1,
 j=null==x?void 0:x.useToFindBestError,
@@ -452,27 +452,27 @@ E=new Date,S=x?s.resolve(x.dir,null!==(o=null===(i=x.getFilePath)||void 0===i?vo
 sessionDate:E}))&&void 0!==o?o:f({sessionDate:E
 })):null,A=null!==(v=n.GC_Iterations)&&void 0!==v?v:1e6,
 P=null!==(g=n.GC_IterationsAsync)&&void 0!==g?g:1e4,
-k=null!==(_=n.GC_Interval)&&void 0!==_?_:1e3,
-I=null!==(y=n.logInterval)&&void 0!==y?y:5e3,
-T=null===(p=n.logCompleted)||void 0===p||p,
-O=n.abortSignal,L=n.findBestError,F=null!==(m=null==L?void 0:L.cycles)&&void 0!==m?m:1,
-V=null==L?void 0:L.dontThrowIfError,
-D=n.limitTime,M=!0===n.parallel?Math.pow(2,31):!n.parallel||n.parallel<=0?1:n.parallel,
+k=null!==(p=n.GC_Interval)&&void 0!==p?p:1e3,
+I=null!==(_=n.logInterval)&&void 0!==_?_:5e3,
+T=null===(y=n.logCompleted)||void 0===y||y,
+O=n.abortSignal,L=n.findBestError,V=null!==(m=null==L?void 0:L.cycles)&&void 0!==m?m:1,
+F=null==L?void 0:L.dontThrowIfError,
+M=n.limitTime,D=!0===n.parallel?Math.pow(2,31):!n.parallel||n.parallel<=0?1:n.parallel,
 null!=n.limitVariantsCount&&t.addLimit({
 index:n.limitVariantsCount}),x?[4,u(x.dir)]:[3,15]
-;case 1:C=_e.sent(),_e.label=2;case 2:
-_e.trys.push([2,13,14,15]),R=c(C),q=R.next(),
-_e.label=3;case 3:
+;case 1:C=pe.sent(),pe.label=2;case 2:
+pe.trys.push([2,13,14,15]),R=c(C),q=R.next(),
+pe.label=3;case 3:
 return q.done?[3,12]:[4,h(q.value,x.jsonToArgs)]
-;case 4:ue=_e.sent(),B=0,_e.label=5;case 5:
-if(!(B<w))return[3,11];_e.label=6;case 6:
-return _e.trys.push([6,9,,10]),b(J=e(ue,-1,null))?[4,J]:[3,8]
-;case 7:_e.sent(),_e.label=8;case 8:return[3,10]
-;case 9:if(N=_e.sent(),j&&L)return t.addLimit({
+;case 4:ue=pe.sent(),B=0,pe.label=5;case 5:
+if(!(B<w))return[3,11];pe.label=6;case 6:
+return pe.trys.push([6,9,,10]),b(J=e(ue,-1,null))?[4,J]:[3,8]
+;case 7:pe.sent(),pe.label=8;case 8:return[3,10]
+;case 9:if(N=pe.sent(),j&&L)return t.addLimit({
 args:ue,error:N}),[3,11];throw N;case 10:
 return B++,[3,5];case 11:return q=R.next(),[3,3]
 ;case 12:return[3,15];case 13:
-return $=_e.sent(),de={error:$},[3,15];case 14:
+return $=pe.sent(),de={error:$},[3,15];case 14:
 try{q&&!q.done&&(ve=R.return)&&ve.call(R)}finally{
 if(de)throw de.error}return[7];case 15:
 G=null,U=null,W=Date.now(),Q=W,K=new z,H=function(...e){
@@ -482,29 +482,29 @@ if(s.aborted)return s
 ;n?(t||(t=new z,n.subscribe(r)),s.subscribe(r)):n=s
 }}return t?t.signal:n||(new z).signal
 }(O,K.signal),ee=H,te=!1,ne=0,re=0,ie=Date.now(),
-se=ie,oe=ne,le=re,ae=M<=1?null:new X(M),
-ce=!1,t.start(),_e.label=16;case 16:
-if(!(t.cycleIndex<F)||ce)return[3,20]
+se=ie,oe=ne,le=re,ae=D<=1?null:new X(D),
+ce=!1,t.start(),pe.label=16;case 16:
+if(!(t.cycleIndex<V)||ce)return[3,20]
 ;ue=void 0,he=function(){
-var n,r,i,s,o,c,u,h,f,v,g,_,y,p,m,w
+var n,r,i,s,o,c,u,h,f,v,g,p,_,y,m,w
 ;return a(this,function(j){switch(j.label){case 0:
-return n=t.index,r=ue,i=(I||k||D)&&Date.now(),
-D&&i-W>=D?(ce=!0,[2,"break"]):(I&&i-ie>=I&&(s="",
+return n=t.index,r=ue,i=(I||k||M)&&Date.now(),
+M&&i-W>=M?(ce=!0,[2,"break"]):(I&&i-ie>=I&&(s="",
 o=i-Q,c=i-W,L?(s+="cycle: ".concat(t.cycleIndex,", variant: ").concat(t.index),
 null!=(u=t.count)&&null!=G&&G<u&&(u=G),
 null!=u&&t.index>0?(h=void 0,null!=U&&null!=G&&t.index<G&&o<U?(f=U-o,
 v=G-t.index,
-g=f/v,_=(u-t.index)*g,h=o+_):h=o*u/t.index,s+="/".concat(u," (").concat(Z(o),"/").concat(Z(h),")")):s+=" (".concat(Z(o),")")):s+="variant: ".concat(t.index," (").concat(Z(o),")"),
+g=f/v,p=(u-t.index)*g,h=o+p):h=o*u/t.index,s+="/".concat(u," (").concat(Z(o),"/").concat(Z(h),")")):s+=" (".concat(Z(o),")")):s+="variant: ".concat(t.index," (").concat(Z(o),")"),
 s+=", total: ".concat(ne," (").concat(Z(c),")"),
 console.log(s),ie=i),A&&ne-oe>=A||P&&re-le>=P||k&&i-se>=k?(oe=ne,
 le=re,se=i,[4,Y(1)]):[3,2]);case 1:
 j.sent(),j.label=2;case 2:
 if(null==O?void 0:O.aborted)return[2,"continue"]
 ;if(ae&&!H.aborted)return[3,10];j.label=3;case 3:
-return j.trys.push([3,6,,9]),b(y=e(r,n,H))?[4,y]:[3,5]
-;case 4:y=j.sent(),j.label=5;case 5:
-return y?(p=y.iterationsAsync,m=y.iterationsSync,
-re+=p,ne+=m+p,[3,9]):(te=!0,K.abort(),
+return j.trys.push([3,6,,9]),b(_=e(r,n,H))?[4,_]:[3,5]
+;case 4:_=j.sent(),j.label=5;case 5:
+return _?(y=_.iterationsAsync,m=_.iterationsSync,
+re+=y,ne+=m+y,[3,9]):(te=!0,K.abort(),
 [2,"continue"]);case 6:
 return w=j.sent(),S?[4,d(r,S,x.argsToJson)]:[3,8]
 ;case 7:j.sent(),j.label=8;case 8:if(!L)throw w
@@ -523,20 +523,20 @@ return l=a.sent(),S?[4,d(r,S,x.argsToJson)]:[3,5]
 ;case 4:a.sent(),a.label=5;case 5:if(!L)throw l
 ;return t.addLimit({error:l}),te=!1,[3,7];case 6:
 return ae.release(1),[7];case 7:return[2]}})
-}),j.label=13;case 13:return[2]}})},_e.label=17
+}),j.label=13;case 13:return[2]}})},pe.label=17
 ;case 17:
 return(null==O?void 0:O.aborted)||!te&&null==(ue=t.next())?[3,19]:[5,he()]
-;case 18:return"break"===_e.sent()?[3,19]:[3,17]
+;case 18:return"break"===pe.sent()?[3,19]:[3,17]
 ;case 19:
 return G=t.count,U=Date.now()-Q,Q=Date.now(),t.start(),[3,16]
-;case 20:return ae?[4,ae.holdWait(M)]:[3,22]
-;case 21:_e.sent(),ae.release(M),_e.label=22
+;case 20:return ae?[4,ae.holdWait(D)]:[3,22]
+;case 21:pe.sent(),ae.release(D),pe.label=22
 ;case 22:
 if(null==ee?void 0:ee.aborted)throw ee.reason
 ;return T&&console.log("[test-variants] variants: ".concat(t.index,", iterations: ").concat(ne,", async: ").concat(re)),
-[4,Y(1)];case 23:if(_e.sent(),(fe=t.limit?{
+[4,Y(1)];case 23:if(pe.sent(),(fe=t.limit?{
 error:t.limit.error,args:t.limit.args,
-index:t.count}:null)&&!V)throw fe.error;return[2,{
+index:t.count}:null)&&!F)throw fe.error;return[2,{
 iterations:ne,bestError:fe}]}})})}
 function te(e,t,n){if(n){
 for(var r=e.length-1;r>=0;r--)if(n(e[r],t))return r
@@ -545,7 +545,7 @@ for(r=e.length-1;r>=0;r--)if(e[r]===t)return r
 ;return-1}function ne(e,t,n){var r=e[n]
 ;return"function"==typeof r?r(t):r}
 function re(e,t){
-var n=e.variants[t].length,r=e.argLimits[t]
+var n=e.argValues[t].length,r=e.argLimits[t]
 ;return null==r?n:r<n?r:n}function ie(e,t,n){
 var r,i,s=Object.keys(e).filter(function(e){
 return"seed"!==e});if(s.length!==n)return!1;try{
@@ -559,92 +559,111 @@ var o=t[s]
 ;if("function"!=typeof o)if(te(o,e[n[s]],i)<0)return!1
 }return!0}function oe(e,t,n,r,i){
 for(var s=!1,o=0;o<r;o++){
-var l=e.indexes[o],a=t[n[o]],c=te(e.variants[o],a,i)
+var l=e.indexes[o],a=t[n[o]],c=te(e.argValues[o],a,i)
 ;if(!(c<0)){if(s=!0,l<c)return!1;if(l>c)return!0}}
-return s}function le(e,t,n,r,i,s,o){
-if(o)for(var l=0;l<i;l++){
-var a=r[l],c=t[a],u=e.variants[l].length>0?e.variants[l]:ne(n,e.args,l),h=te(u,c,s)
-;if(!(h<=0)){if("function"==typeof o)if(!o({
-name:a,valueIndex:h,values:u,
-maxValueIndex:e.argLimits[l]}))continue
-;var f=e.argLimits[l]
-;(null==f||h<f)&&(e.argLimits[l]=h)}}}
-function ae(e){
+return s}function le(e,t,n,r,i){
+for(var s=[],o=0;o<r;o++){
+var l=e[n[o]],a=te(ne(t,e,o),l,i)
+;if(a<0)return null;s.push(a)}return s}
+function ae(e,t,n,r,i,s,o,l){if(!l)return!1
+;var a=le(t,r,i,s,o);if(!a)return!1;if(n){
+var c=le(n,r,i,s,o);if(c){var u=function(e,t){
+for(var n,r,i=Math.max(e.length,t.length),s=0;s<i;s++){
+var o=null!==(n=e[s])&&void 0!==n?n:0,l=null!==(r=t[s])&&void 0!==r?r:0
+;if(o<l)return-1;if(o>l)return 1}return 0}(a,c)
+;if(u>=0)return!1}}for(var h=0;h<s;h++){var f=a[h]
+;if("function"==typeof l)if(!l({name:i[h],
+valueIndex:f,values:ne(r,t,h),
+maxValueIndex:e.argLimits[h]})){
+e.argLimits[h]=null;continue}
+e.argLimits[h]=f>0?f:null}
+return e.pendingLimits=e.pendingLimits.filter(function(t){
+for(var n=0;n<s;n++){
+var l=t.args[i[n]],a=te(ne(r,t.args,n),l,o),c=e.argLimits[n]
+;if(null!=c&&a>=c)return!1}return!0}),!0}
+function ce(e){
 for(var t=e.argsTemplates,n=e.getSeed,r=e.repeatsPerVariant,i=e.equals,s=e.limitArgOnError,l=null!=r?r:1,a=Object.keys(t),c=Object.values(t),u=a.length,h=new Set(a),f=[],d=[],v=[],g=0;g<u;g++)f[g]=-1,
-d[g]=[],v[g]=null;var _={args:{},indexes:f,
-variants:d,argLimits:v,index:-1,cycleIndex:-1,
+d[g]=[],v[g]=null;var p={args:{},indexes:f,
+argValues:d,argLimits:v,index:-1,cycleIndex:-1,
 repeatIndex:0,count:null,limit:null,started:!1,
-currentArgs:null,pendingLimits:[]},y={get index(){
-return _.index},get cycleIndex(){
-return _.cycleIndex},get count(){return _.count},
-get limit(){return _.limit},addLimit:function(e){
-var t=void 0!==(null==e?void 0:e.args)&&null!==e.args,n=null!=(null==e?void 0:e.index)
-;if(t||n)if(!n||t)if(!t||n){if(t&&n){
-var r=null==_.count||e.index<_.count
-;if(r&&(_.count=e.index),!ie(e.args,h,u))return
-;if(!se(e.args,c,a,u,i))return
-;r&&(_.limit=void 0!==e.error?{args:e.args,
+currentArgs:null,pendingLimits:[]},_={get index(){
+return p.index},get cycleIndex(){
+return p.cycleIndex},get count(){return p.count},
+get limit(){return p.limit},addLimit:function(e){
+var t,n,r,o,l,f,d=void 0!==(null==e?void 0:e.args)&&null!==e.args,v=null!=(null==e?void 0:e.index)
+;if(d||v)if(!v||d)if(!d||v){if(d&&v){
+var g=null==p.count||e.index<p.count
+;if(g&&(p.count=e.index),!ie(e.args,h,u))return
+;if(!se(e.args,c,a,u,i))return;if(g){
+_=null!==(f=null===(l=p.limit)||void 0===l?void 0:l.args)&&void 0!==f?f:null
+;p.limit=void 0!==e.error?{args:e.args,
 error:e.error}:{args:e.args
-},le(_,e.args,c,a,u,i,s))}}else{
+},ae(p,e.args,_,c,a,u,i,s)}}}else{
 if(!ie(e.args,h,u))return
 ;if(!se(e.args,c,a,u,i))return
-;le(_,e.args,c,a,u,i,s);var o=void 0!==e.error?{
-args:e.args,error:e.error}:{args:e.args}
-;_.pendingLimits.push(o)
-}else(null==_.count||e.index<_.count)&&(_.count=e.index);else{
-if(_.index<0)throw new Error("[testVariantsIterator] addLimit() requires at least one next() call")
-;(null==_.count||_.index<_.count)&&(_.count=_.index,
-_.limit=void 0!==(null==e?void 0:e.error)?{
-args:_.currentArgs,error:e.error}:{
-args:_.currentArgs},le(_,_.args,c,a,u,i,s))}},
-start:function(){_.cycleIndex++,function(e,t,n){
+;var _=null!==(o=null===(r=p.limit)||void 0===r?void 0:r.args)&&void 0!==o?o:null
+;if(ae(p,e.args,_,c,a,u,i,s))p.limit=void 0!==e.error?{
+args:e.args,error:e.error}:{args:e.args
+};else if(!s){var y=void 0!==e.error?{args:e.args,
+error:e.error}:{args:e.args}
+;p.pendingLimits.push(y)}
+}else(null==p.count||e.index<p.count)&&(p.count=e.index);else{
+if(p.index<0)throw new Error("[testVariantsIterator] addLimit() requires at least one next() call")
+;if(null==p.count||p.index<p.count){
+var _=null!==(n=null===(t=p.limit)||void 0===t?void 0:t.args)&&void 0!==n?n:null
+;p.count=p.index,
+p.limit=void 0!==(null==e?void 0:e.error)?{
+args:p.currentArgs,error:e.error}:{
+args:p.currentArgs},ae(p,p.args,_,c,a,u,i,s)}}},
+start:function(){p.cycleIndex++,function(e,t,n){
 e.index=-1,e.repeatIndex=0
-;for(var r=0;r<n;r++)e.indexes[r]=-1,e.variants[r]=[]
-;n>0&&(e.variants[0]=ne(t,e.args,0))
-}(_,c,u),_.started=!0},next:function(){
-if(!_.started)throw new Error("[testVariantsIterator] start() must be called before next()")
-;if(_.index>=0&&_.repeatIndex+1<l&&(null==_.count||_.index<_.count)){
-if(_.repeatIndex++,n){var e=n({
-variantIndex:_.index,cycleIndex:_.cycleIndex,
-repeatIndex:_.repeatIndex})
-;_.currentArgs=o(o({},_.args),{seed:e})
-}else _.currentArgs=o({},_.args)
-;return _.currentArgs}
-if(_.repeatIndex=0,!function(e,t,n,r){
+;for(var r=0;r<n;r++)e.indexes[r]=-1,e.argValues[r]=[]
+;n>0&&(e.argValues[0]=ne(t,e.args,0))
+}(p,c,u),p.started=!0},next:function(){
+if(!p.started)throw new Error("[testVariantsIterator] start() must be called before next()")
+;if(p.index>=0&&p.repeatIndex+1<l&&(null==p.count||p.index<p.count)){
+if(p.repeatIndex++,n){var e=n({
+variantIndex:p.index,cycleIndex:p.cycleIndex,
+repeatIndex:p.repeatIndex})
+;p.currentArgs=o(o({},p.args),{seed:e})
+}else p.currentArgs=o({},p.args)
+;return p.currentArgs}
+if(p.repeatIndex=0,!function(e,t,n,r){
 for(var i,s=r-1;s>=0;s--){var o=e.indexes[s]+1
-;if(o<re(e,s)){var l=n[s],a=e.variants[s][o]
+;if(o<re(e,s)){var l=n[s],a=e.argValues[s][o]
 ;for(e.indexes[s]=o,e.args[l]=a,s++;s<r;s++){
 var c=ne(t,e.args,s),u=null!==(i=e.argLimits[s])&&void 0!==i?i:c.length
 ;if(0===c.length||u<=0)break
-;e.indexes[s]=0,e.variants[s]=c;var h=n[s],f=c[0]
+;e.indexes[s]=0,e.argValues[s]=c;var h=n[s],f=c[0]
 ;e.args[h]=f}if(s>=r)return!0}}return!1
-}(_,c,a,u))return null==_.count&&(_.count=_.index+1),
+}(p,c,a,u))return null==p.count&&(p.count=p.index+1),
 null
-;if(_.index++,_.pendingLimits.length>0&&function(e,t,n,r,i,s){
-for(var o=!1,l=e.pendingLimits.length-1;l>=0;l--){
-var a=e.pendingLimits[l]
-;oe(e,a.args,n,r,i)&&((null==e.count||e.index<e.count)&&(e.count=e.index,
-e.limit=void 0!==a.error?{args:a.args,
-error:a.error}:{args:a.args
-},le(e,a.args,t,n,r,i,s),o=!0),e.pendingLimits.splice(l,1))
-}
-}(_,c,a,u,i,s),null!=_.count&&_.index>=_.count)return null
-;if(n){e=n({variantIndex:_.index,
-cycleIndex:_.cycleIndex,repeatIndex:_.repeatIndex
-});_.currentArgs=o(o({},_.args),{seed:e})
-}else _.currentArgs=o({},_.args)
-;return _.currentArgs}};return y}
+;if(p.index++,p.pendingLimits.length>0&&function(e,t,n,r,i,s){
+for(var o,l,a=!1,c=e.pendingLimits.length-1;c>=0;c--){
+var u=e.pendingLimits[c];if(oe(e,u.args,n,r,i)){
+if(null==e.count||e.index<e.count){
+var h=null!==(l=null===(o=e.limit)||void 0===o?void 0:o.args)&&void 0!==l?l:null
+;e.count=e.index,e.limit=void 0!==u.error?{
+args:u.args,error:u.error}:{args:u.args
+},ae(e,u.args,h,t,n,r,i,s),a=!0}
+e.pendingLimits.splice(c,1)}}
+}(p,c,a,u,i,s),null!=p.count&&p.index>=p.count)return null
+;if(n){e=n({variantIndex:p.index,
+cycleIndex:p.cycleIndex,repeatIndex:p.repeatIndex
+});p.currentArgs=o(o({},p.args),{seed:e})
+}else p.currentArgs=o({},p.args)
+;return p.currentArgs}};return _}
 e.createTestVariants=function(e){
 return function(t){return function(n){var r,i,s,o
 ;return l(this,void 0,void 0,function(){var l,c
 ;return a(this,function(a){return l=L(e,{
-onError:null==n?void 0:n.onError}),c=ae({
+onError:null==n?void 0:n.onError}),c=ce({
 argsTemplates:t,
 getSeed:null===(r=null==n?void 0:n.findBestError)||void 0===r?void 0:r.getSeed,
 repeatsPerVariant:null===(i=null==n?void 0:n.findBestError)||void 0===i?void 0:i.repeatsPerVariant,
 equals:null===(s=null==n?void 0:n.findBestError)||void 0===s?void 0:s.equals,
 limitArgOnError:null===(o=null==n?void 0:n.findBestError)||void 0===o?void 0:o.limitArgOnError
 }),[2,ee(l,c,n)]})})}}
-},e.generateErrorVariantFilePath=f,e.testVariantsIterator=ae,
+},e.generateErrorVariantFilePath=f,e.testVariantsIterator=ce,
 Object.defineProperty(e,"__esModule",{value:!0})
 }({},fs,path);

package/dist/lib/test-variants/testVariantsIterator.cjs

@@ -33,20 +33,20 @@ function resetIteratorState(state, templates, keysCount) {
     state.repeatIndex = 0;
     for (let i = 0; i < keysCount; i++) {
         state.indexes[i] = -1;
-        state.variants[i] = [];
+        state.argValues[i] = [];
     }
     if (keysCount > 0) {
-        state.variants[0] = calcTemplateValues(templates, state.args, 0);
+        state.argValues[0] = calcTemplateValues(templates, state.args, 0);
     }
 }
 /** Get effective max index for an arg (considering argLimit) */
 function getMaxIndex(state, keyIndex) {
-    const variantsLen = state.variants[keyIndex].length;
+    const valuesLen = state.argValues[keyIndex].length;
     const argLimit = state.argLimits[keyIndex];
     if (argLimit == null) {
-        return variantsLen;
+        return valuesLen;
     }
-    return argLimit < variantsLen ? argLimit : variantsLen;
+    return argLimit < valuesLen ? argLimit : valuesLen;
 }
 /** Advance to next variant in cartesian product; returns true if successful */
 function advanceVariant(state, templates, keys, keysCount) {
@@ -56,7 +56,7 @@ function advanceVariant(state, templates, keys, keysCount) {
         const maxIndex = getMaxIndex(state, keyIndex);
         if (valueIndex < maxIndex) {
             const key = keys[keyIndex];
-            const value = state.variants[keyIndex][valueIndex];
+            const value = state.argValues[keyIndex][valueIndex];
             state.indexes[keyIndex] = valueIndex;
             state.args[key] = value;
             for (keyIndex++; keyIndex < keysCount; keyIndex++) {
@@ -66,7 +66,7 @@ function advanceVariant(state, templates, keys, keysCount) {
                     break;
                 }
                 state.indexes[keyIndex] = 0;
-                state.variants[keyIndex] = keyVariants;
+                state.argValues[keyIndex] = keyVariants;
                 const key = keys[keyIndex];
                 const value = keyVariants[0];
                 state.args[key] = value;
@@ -110,7 +110,7 @@ function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
     for (let i = 0; i < keysCount; i++) {
         const currentValueIndex = state.indexes[i];
         const pendingValue = pendingArgs[keys[i]];
-        const pendingValueIndex = findLastIndex(state.variants[i], pendingValue, equals);
+        const pendingValueIndex = findLastIndex(state.argValues[i], pendingValue, equals);
         // Dynamic template value not found - skip this arg from comparison
         if (pendingValueIndex < 0) {
             continue;
@@ -126,24 +126,66 @@ function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
     // All compared args are equal - position reached; or all args skipped - keep pending
     return anyCompared;
 }
-/** Update per-arg limits from args values */
-function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, limitArgOnError) {
-    if (!limitArgOnError) {
-        return;
-    }
+/** Calculate indexes for given args; returns null if any value not found */
+function calcArgsIndexes(limitArgs, templates, keys, keysCount, equals) {
+    const indexes = [];
     for (let i = 0; i < keysCount; i++) {
         const key = keys[i];
         const value = limitArgs[key];
-        const values = state.variants[i].length > 0
-            ? state.variants[i]
-            : calcTemplateValues(templates, state.args, i);
+        // Use limitArgs for dynamic template calculation
+        const values = calcTemplateValues(templates, limitArgs, i);
         const valueIndex = findLastIndex(values, value, equals);
-        // Skip if value not found or already at index 0
-        if (valueIndex <= 0) {
-            continue;
+        if (valueIndex < 0) {
+            return null;
+        }
+        indexes.push(valueIndex);
+    }
+    return indexes;
+}
+/** Compare two index arrays lexicographically; returns -1 if a < b, 0 if equal, 1 if a > b */
+function compareLexicographic(a, b) {
+    var _a, _b;
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const ai = (_a = a[i]) !== null && _a !== void 0 ? _a : 0;
+        const bi = (_b = b[i]) !== null && _b !== void 0 ? _b : 0;
+        if (ai < bi) {
+            return -1;
+        }
+        if (ai > bi) {
+            return 1;
+        }
+    }
+    return 0;
+}
+/** Update per-arg limits from args values using lexicographic comparison; returns true if updated */
+function updateArgLimits(state, limitArgs, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError) {
+    if (!limitArgOnError) {
+        return false;
+    }
+    // Calculate indexes for new limit args
+    const newIndexes = calcArgsIndexes(limitArgs, templates, keys, keysCount, equals);
+    if (!newIndexes) {
+        return false; // Value not found, can't apply limit
+    }
+    // If we have existing limit, compare lexicographically
+    if (oldLimitArgs) {
+        const currentIndexes = calcArgsIndexes(oldLimitArgs, templates, keys, keysCount, equals);
+        if (currentIndexes) {
+            const cmp = compareLexicographic(newIndexes, currentIndexes);
+            if (cmp >= 0) {
+                // New is larger or equal - reject entirely
+                return false;
+            }
         }
+    }
+    // New is smaller (or first limit) - replace all argLimits
+    for (let i = 0; i < keysCount; i++) {
+        const valueIndex = newIndexes[i];
         // Check callback if provided
         if (typeof limitArgOnError === 'function') {
+            const key = keys[i];
+            const values = calcTemplateValues(templates, limitArgs, i);
             const shouldLimit = limitArgOnError({
                 name: key,
                 valueIndex,
@@ -151,29 +193,43 @@ function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, l
                 maxValueIndex: state.argLimits[i],
             });
             if (!shouldLimit) {
+                state.argLimits[i] = null;
                 continue;
             }
         }
-        // Update limit: argLimit = min(current argLimit, valueIndex)
-        const currentLimit = state.argLimits[i];
-        if (currentLimit == null || valueIndex < currentLimit) {
-            state.argLimits[i] = valueIndex;
-        }
+        // Set argLimit: index 0 can't be limited further, store null
+        state.argLimits[i] = valueIndex > 0 ? valueIndex : null;
     }
+    // Filter out pending limits that are now excluded by argLimits
+    state.pendingLimits = state.pendingLimits.filter(pending => {
+        for (let i = 0; i < keysCount; i++) {
+            const value = pending.args[keys[i]];
+            const values = calcTemplateValues(templates, pending.args, i);
+            const valueIndex = findLastIndex(values, value, equals);
+            const argLimit = state.argLimits[i];
+            if (argLimit != null && valueIndex >= argLimit) {
+                return false; // Pending position is excluded by argLimits
+            }
+        }
+        return true; // Keep
+    });
+    return true;
 }
 /** Process pending limits; returns true if any limit was applied */
 function processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError) {
+    var _a, _b;
     let applied = false;
     for (let i = state.pendingLimits.length - 1; i >= 0; i--) {
         const pending = state.pendingLimits[i];
         if (isPositionReached(state, pending.args, keys, keysCount, equals)) {
             // Current position >= pending position: apply limit
             if (state.count == null || state.index < state.count) {
+                const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
                 state.count = state.index;
                 state.limit = typeof pending.error !== 'undefined'
                     ? { args: pending.args, error: pending.error }
                     : { args: pending.args };
-                updateArgLimits(state, pending.args, templates, keys, keysCount, equals, limitArgOnError);
+                updateArgLimits(state, pending.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 applied = true;
             }
             // Remove from pending
@@ -192,17 +248,17 @@ function testVariantsIterator(options) {
     const keysSet = new Set(keys);
     // Initialize state
     const indexes = [];
-    const variants = [];
+    const argValues = [];
     const argLimits = [];
     for (let i = 0; i < keysCount; i++) {
         indexes[i] = -1;
-        variants[i] = [];
+        argValues[i] = [];
         argLimits[i] = null;
     }
     const state = {
         args: {},
         indexes,
-        variants,
+        argValues,
         argLimits,
         index: -1,
         cycleIndex: -1,
@@ -227,6 +283,7 @@ function testVariantsIterator(options) {
             return state.limit;
         },
         addLimit(_options) {
+            var _a, _b, _c, _d, _e, _f;
             const hasArgs = typeof (_options === null || _options === void 0 ? void 0 : _options.args) !== 'undefined' && _options.args !== null;
             const hasIndex = (_options === null || _options === void 0 ? void 0 : _options.index) != null;
             // addLimit() or addLimit({error}) - uses current args and index
@@ -235,11 +292,12 @@ function testVariantsIterator(options) {
                     throw new Error('[testVariantsIterator] addLimit() requires at least one next() call');
                 }
                 if (state.count == null || state.index < state.count) {
+                    const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
                     state.count = state.index;
                     state.limit = typeof (_options === null || _options === void 0 ? void 0 : _options.error) !== 'undefined'
                         ? { args: state.currentArgs, error: _options.error }
                         : { args: state.currentArgs };
-                    updateArgLimits(state, state.args, templates, keys, keysCount, equals, limitArgOnError);
+                    updateArgLimits(state, state.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 }
                 return;
             }
@@ -260,13 +318,24 @@ function testVariantsIterator(options) {
                 if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
                     return; // Discard - unreproducible (value not in template)
                 }
-                // Apply per-arg limits immediately for static templates
-                updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
-                // Store as pending limit for count/position-based limiting
-                const pending = typeof _options.error !== 'undefined'
-                    ? { args: _options.args, error: _options.error }
-                    : { args: _options.args };
-                state.pendingLimits.push(pending);
+                // Apply per-arg limits immediately (if limitArgOnError enabled)
+                const oldLimitArgs = (_d = (_c = state.limit) === null || _c === void 0 ? void 0 : _c.args) !== null && _d !== void 0 ? _d : null;
+                const updated = updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
+                if (updated) {
+                    // argLimits updated - this is the new best, update state.limit for future comparisons
+                    state.limit = typeof _options.error !== 'undefined'
+                        ? { args: _options.args, error: _options.error }
+                        : { args: _options.args };
+                    // Pending limit at this position is now filtered by argLimits, don't add
+                }
+                else if (!limitArgOnError) {
+                    // No argLimits filtering - add pending limit for position-based stopping
+                    const pending = typeof _options.error !== 'undefined'
+                        ? { args: _options.args, error: _options.error }
+                        : { args: _options.args };
+                    state.pendingLimits.push(pending);
+                }
+                // If limitArgOnError and not updated (lexicographically larger), discard entirely
                 return;
             }
             // addLimit({args, index}) or addLimit({args, index, error}) - immediate index + pending args
@@ -286,10 +355,11 @@ function testVariantsIterator(options) {
                 }
                 // Update limit if this is earliest
                 if (isEarliest) {
+                    const oldLimitArgs = (_f = (_e = state.limit) === null || _e === void 0 ? void 0 : _e.args) !== null && _f !== void 0 ? _f : null;
                     state.limit = typeof _options.error !== 'undefined'
                         ? { args: _options.args, error: _options.error }
                         : { args: _options.args };
-                    updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
+                    updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 }
             }
         },

package/dist/lib/test-variants/testVariantsIterator.mjs

@@ -29,20 +29,20 @@ function resetIteratorState(state, templates, keysCount) {
     state.repeatIndex = 0;
     for (let i = 0; i < keysCount; i++) {
         state.indexes[i] = -1;
-        state.variants[i] = [];
+        state.argValues[i] = [];
     }
     if (keysCount > 0) {
-        state.variants[0] = calcTemplateValues(templates, state.args, 0);
+        state.argValues[0] = calcTemplateValues(templates, state.args, 0);
     }
 }
 /** Get effective max index for an arg (considering argLimit) */
 function getMaxIndex(state, keyIndex) {
-    const variantsLen = state.variants[keyIndex].length;
+    const valuesLen = state.argValues[keyIndex].length;
     const argLimit = state.argLimits[keyIndex];
     if (argLimit == null) {
-        return variantsLen;
+        return valuesLen;
     }
-    return argLimit < variantsLen ? argLimit : variantsLen;
+    return argLimit < valuesLen ? argLimit : valuesLen;
 }
 /** Advance to next variant in cartesian product; returns true if successful */
 function advanceVariant(state, templates, keys, keysCount) {
@@ -52,7 +52,7 @@ function advanceVariant(state, templates, keys, keysCount) {
         const maxIndex = getMaxIndex(state, keyIndex);
         if (valueIndex < maxIndex) {
             const key = keys[keyIndex];
-            const value = state.variants[keyIndex][valueIndex];
+            const value = state.argValues[keyIndex][valueIndex];
             state.indexes[keyIndex] = valueIndex;
             state.args[key] = value;
             for (keyIndex++; keyIndex < keysCount; keyIndex++) {
@@ -62,7 +62,7 @@ function advanceVariant(state, templates, keys, keysCount) {
                     break;
                 }
                 state.indexes[keyIndex] = 0;
-                state.variants[keyIndex] = keyVariants;
+                state.argValues[keyIndex] = keyVariants;
                 const key = keys[keyIndex];
                 const value = keyVariants[0];
                 state.args[key] = value;
@@ -106,7 +106,7 @@ function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
     for (let i = 0; i < keysCount; i++) {
         const currentValueIndex = state.indexes[i];
         const pendingValue = pendingArgs[keys[i]];
-        const pendingValueIndex = findLastIndex(state.variants[i], pendingValue, equals);
+        const pendingValueIndex = findLastIndex(state.argValues[i], pendingValue, equals);
         // Dynamic template value not found - skip this arg from comparison
         if (pendingValueIndex < 0) {
             continue;
@@ -122,24 +122,66 @@ function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
     // All compared args are equal - position reached; or all args skipped - keep pending
     return anyCompared;
 }
-/** Update per-arg limits from args values */
-function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, limitArgOnError) {
-    if (!limitArgOnError) {
-        return;
-    }
+/** Calculate indexes for given args; returns null if any value not found */
+function calcArgsIndexes(limitArgs, templates, keys, keysCount, equals) {
+    const indexes = [];
     for (let i = 0; i < keysCount; i++) {
         const key = keys[i];
         const value = limitArgs[key];
-        const values = state.variants[i].length > 0
-            ? state.variants[i]
-            : calcTemplateValues(templates, state.args, i);
+        // Use limitArgs for dynamic template calculation
+        const values = calcTemplateValues(templates, limitArgs, i);
         const valueIndex = findLastIndex(values, value, equals);
-        // Skip if value not found or already at index 0
-        if (valueIndex <= 0) {
-            continue;
+        if (valueIndex < 0) {
+            return null;
+        }
+        indexes.push(valueIndex);
+    }
+    return indexes;
+}
+/** Compare two index arrays lexicographically; returns -1 if a < b, 0 if equal, 1 if a > b */
+function compareLexicographic(a, b) {
+    var _a, _b;
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const ai = (_a = a[i]) !== null && _a !== void 0 ? _a : 0;
+        const bi = (_b = b[i]) !== null && _b !== void 0 ? _b : 0;
+        if (ai < bi) {
+            return -1;
+        }
+        if (ai > bi) {
+            return 1;
+        }
+    }
+    return 0;
+}
+/** Update per-arg limits from args values using lexicographic comparison; returns true if updated */
+function updateArgLimits(state, limitArgs, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError) {
+    if (!limitArgOnError) {
+        return false;
+    }
+    // Calculate indexes for new limit args
+    const newIndexes = calcArgsIndexes(limitArgs, templates, keys, keysCount, equals);
+    if (!newIndexes) {
+        return false; // Value not found, can't apply limit
+    }
+    // If we have existing limit, compare lexicographically
+    if (oldLimitArgs) {
+        const currentIndexes = calcArgsIndexes(oldLimitArgs, templates, keys, keysCount, equals);
+        if (currentIndexes) {
+            const cmp = compareLexicographic(newIndexes, currentIndexes);
+            if (cmp >= 0) {
+                // New is larger or equal - reject entirely
+                return false;
+            }
         }
+    }
+    // New is smaller (or first limit) - replace all argLimits
+    for (let i = 0; i < keysCount; i++) {
+        const valueIndex = newIndexes[i];
         // Check callback if provided
         if (typeof limitArgOnError === 'function') {
+            const key = keys[i];
+            const values = calcTemplateValues(templates, limitArgs, i);
             const shouldLimit = limitArgOnError({
                 name: key,
                 valueIndex,
@@ -147,29 +189,43 @@ function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, l
                 maxValueIndex: state.argLimits[i],
             });
             if (!shouldLimit) {
+                state.argLimits[i] = null;
                 continue;
             }
         }
-        // Update limit: argLimit = min(current argLimit, valueIndex)
-        const currentLimit = state.argLimits[i];
-        if (currentLimit == null || valueIndex < currentLimit) {
-            state.argLimits[i] = valueIndex;
-        }
+        // Set argLimit: index 0 can't be limited further, store null
+        state.argLimits[i] = valueIndex > 0 ? valueIndex : null;
     }
+    // Filter out pending limits that are now excluded by argLimits
+    state.pendingLimits = state.pendingLimits.filter(pending => {
+        for (let i = 0; i < keysCount; i++) {
+            const value = pending.args[keys[i]];
+            const values = calcTemplateValues(templates, pending.args, i);
+            const valueIndex = findLastIndex(values, value, equals);
+            const argLimit = state.argLimits[i];
+            if (argLimit != null && valueIndex >= argLimit) {
+                return false; // Pending position is excluded by argLimits
+            }
+        }
+        return true; // Keep
+    });
+    return true;
 }
 /** Process pending limits; returns true if any limit was applied */
 function processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError) {
+    var _a, _b;
     let applied = false;
     for (let i = state.pendingLimits.length - 1; i >= 0; i--) {
         const pending = state.pendingLimits[i];
         if (isPositionReached(state, pending.args, keys, keysCount, equals)) {
             // Current position >= pending position: apply limit
             if (state.count == null || state.index < state.count) {
+                const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
                 state.count = state.index;
                 state.limit = typeof pending.error !== 'undefined'
                     ? { args: pending.args, error: pending.error }
                     : { args: pending.args };
-                updateArgLimits(state, pending.args, templates, keys, keysCount, equals, limitArgOnError);
+                updateArgLimits(state, pending.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 applied = true;
             }
             // Remove from pending
@@ -188,17 +244,17 @@ function testVariantsIterator(options) {
     const keysSet = new Set(keys);
     // Initialize state
     const indexes = [];
-    const variants = [];
+    const argValues = [];
     const argLimits = [];
     for (let i = 0; i < keysCount; i++) {
         indexes[i] = -1;
-        variants[i] = [];
+        argValues[i] = [];
         argLimits[i] = null;
     }
     const state = {
         args: {},
         indexes,
-        variants,
+        argValues,
         argLimits,
         index: -1,
         cycleIndex: -1,
@@ -223,6 +279,7 @@ function testVariantsIterator(options) {
             return state.limit;
         },
         addLimit(_options) {
+            var _a, _b, _c, _d, _e, _f;
             const hasArgs = typeof (_options === null || _options === void 0 ? void 0 : _options.args) !== 'undefined' && _options.args !== null;
             const hasIndex = (_options === null || _options === void 0 ? void 0 : _options.index) != null;
             // addLimit() or addLimit({error}) - uses current args and index
@@ -231,11 +288,12 @@ function testVariantsIterator(options) {
                     throw new Error('[testVariantsIterator] addLimit() requires at least one next() call');
                 }
                 if (state.count == null || state.index < state.count) {
+                    const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
                     state.count = state.index;
                     state.limit = typeof (_options === null || _options === void 0 ? void 0 : _options.error) !== 'undefined'
                         ? { args: state.currentArgs, error: _options.error }
                         : { args: state.currentArgs };
-                    updateArgLimits(state, state.args, templates, keys, keysCount, equals, limitArgOnError);
+                    updateArgLimits(state, state.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 }
                 return;
             }
@@ -256,13 +314,24 @@ function testVariantsIterator(options) {
                 if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
                     return; // Discard - unreproducible (value not in template)
                 }
-                // Apply per-arg limits immediately for static templates
-                updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
-                // Store as pending limit for count/position-based limiting
-                const pending = typeof _options.error !== 'undefined'
-                    ? { args: _options.args, error: _options.error }
-                    : { args: _options.args };
-                state.pendingLimits.push(pending);
+                // Apply per-arg limits immediately (if limitArgOnError enabled)
+                const oldLimitArgs = (_d = (_c = state.limit) === null || _c === void 0 ? void 0 : _c.args) !== null && _d !== void 0 ? _d : null;
+                const updated = updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
+                if (updated) {
+                    // argLimits updated - this is the new best, update state.limit for future comparisons
+                    state.limit = typeof _options.error !== 'undefined'
+                        ? { args: _options.args, error: _options.error }
+                        : { args: _options.args };
+                    // Pending limit at this position is now filtered by argLimits, don't add
+                }
+                else if (!limitArgOnError) {
+                    // No argLimits filtering - add pending limit for position-based stopping
+                    const pending = typeof _options.error !== 'undefined'
+                        ? { args: _options.args, error: _options.error }
+                        : { args: _options.args };
+                    state.pendingLimits.push(pending);
+                }
+                // If limitArgOnError and not updated (lexicographically larger), discard entirely
                 return;
             }
             // addLimit({args, index}) or addLimit({args, index, error}) - immediate index + pending args
@@ -282,10 +351,11 @@ function testVariantsIterator(options) {
                 }
                 // Update limit if this is earliest
                 if (isEarliest) {
+                    const oldLimitArgs = (_f = (_e = state.limit) === null || _e === void 0 ? void 0 : _e.args) !== null && _f !== void 0 ? _f : null;
                     state.limit = typeof _options.error !== 'undefined'
                         ? { args: _options.args, error: _options.error }
                         : { args: _options.args };
-                    updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
+                    updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
                 }
             }
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flemist/test-variants",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Runs a test function with all possible combinations of its parameters.",
   "main": "dist/lib/index.cjs",
   "module": "dist/lib/index.mjs",