@shd101wyy/yo 0.1.19 → 0.1.21

package/out/esm/index.mjs

@@ -149,7 +149,7 @@ Given: "${S(t.type)}"`)}}}return{expectedEnv:e.env,givenEnv:t.env}}function vl(e
 `)}function gc(e){let t={moduleDoc:null,declarations:[]},n=[],r=null,i="",o=0;for(;o<e.length;){let a=e[o];if(ag(a))if(r===null&&(r=a.position,i=a.modulePath),a.type==="inner_doc_line_comment"){for(n.push($l(a.value)),o++;o<e.length&&e[o].type==="whitespace";){if(e[o].value.includes(`
 `)){let s=o+1;for(;s<e.length&&e[s].type==="whitespace";)s++;if(s<e.length&&e[s].type==="inner_doc_line_comment"){o=s;break}else break}o++}continue}else{n.push(mc(a.value)),o++;continue}if(a.type==="doc_line_comment"){let s=[],l=a.position,u=a.modulePath;for(s.push($l(a.value)),o++;o<e.length;){let p=o;for(;p<e.length&&e[p].type==="whitespace";)p++;if(p<e.length&&e[p].type==="doc_line_comment")s.push($l(e[p].value)),o=p+1;else break}let c={content:s.join(`
 `),inner:!1,position:l,modulePath:u},{name:_,position:f}=yc(e,o);t.declarations.push({comment:c,declarationName:_,declarationPosition:f});continue}if(a.type==="doc_block_comment"){let s={content:mc(a.value),inner:!1,position:a.position,modulePath:a.modulePath};o++;let{name:l,position:u}=yc(e,o);t.declarations.push({comment:s,declarationName:l,declarationPosition:u});continue}o++}return n.length>0&&r!==null&&(t.moduleDoc={content:n.join(`
-`),inner:!0,position:r,modulePath:i}),t}function yc(e,t){let n=t;for(;n<e.length;){let r=e[n];if(sg(r)||og(r)){n++;continue}if(r.type==="identifier")return{name:r.value,position:r.position};if(r.type==="("){n++;continue}return{name:"",position:null}}return{name:"",position:null}}function gs(e){return E(e,["->","=>"])?!!(e.$?.isAnonymousFunctionDefinition===!0||F(e)&&F(e.func)&&(E(e.func,V.fn)||E(e.func,V.unsafe_fn)||E(e.func,V.Fn))||!e.$):!1}function hs(e,t){if(!F(e))return!1;if(t(e.func))return!0;for(let n of e.args)if(F(n)&&E(n,"=>")){for(let r of n.args)if(t(r))return!0}else if(t(n))return!0;return!1}function cr(e){if(B(e))return ht(e,V.escape);if(F(e)){if(e.$?.macroExpansion)return cr(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,cr);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(cr(e.func))return!0;for(let t of e.args)if(cr(t))return!0}return!1}function uo(e){if(B(e))return ht(e,V.return)||ht(e,V.escape);if(F(e)){if(E(e,V.return)||E(e,V.escape))return!0;if(e.$?.macroExpansion)return uo(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,uo);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(uo(e.func))return!0;for(let t of e.args)if(uo(t))return!0}return!1}function pn(e){if(F(e)){if(e.func.$?.type?.ioBuiltin==="io_await")return!0;if(e.$?.macroExpansion)return pn(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,pn);if(e.func.$?.type?.ioBuiltin==="io_async"||gs(e)||O(e.func.$?.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(pn(e.func))return!0;for(let t of e.args)if(pn(t))return!0}return!1}function co(e){if(B(e))return ht(e,V.break)||ht(e,V.return)||ht(e,V.escape);if(F(e)){if(E(e,V.return)||E(e,V.escape))return!0;if(e.$?.macroExpansion)return co(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,co);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(co(e.func))return!0;for(let t of e.args)if(co(t))return!0}return!1}var Q={tag:"Unit",type:Yn()};function Xo(e){if(e&&e.tag==="FnCall"&&E(e,":=")){let t=e.args[0];if(t&&t.tag==="Atom"&&t.token.type==="identifier"&&t.$){let n=t.token.value,r=K(t.$.env,n);if(r.length>0)return r[r.length-1].id}}}function vs(e,t){let n=[],r=new Map,i=new Map,o=new Map;if(Lr(e,n,r,i,o,t),e.$?.deferredDropExpressions)for(let a of e.$.deferredDropExpressions)Lr(a,n,r,i,o,t);return n.length===0&&r.clear(),{suspensionPoints:n,capturedVariables:Array.from(r.values()),hasSuspensions:n.length>0,variableIdRemapping:o}}function Lr(e,t,n,r,i,o,a){switch(e.tag){case"Atom":if(e.$&&e.token.type==="identifier"){let s=e.token.value,l=e.$.type,u=K(e.$.env,s);if(u.length>0){let c=u[u.length-1];if(c&&!n.has(c.id)&&!c.isCompileTimeOnly){let _=`${c.name}:${c.frameLevel}`,f=r.get(_);if(f&&f!==c.id)i.set(c.id,f);else if(c.isOwningTheSameRcValueAs){let p=c.isOwningTheSameRcValueAs;if(!n.has(p.id)){let d={id:p.id,name:p.name,type:p.type,isOwningTheSameRcValueAs:void 0};n.set(p.id,d);let h=`${p.name}:${p.frameLevel}`;r.has(h)||r.set(h,p.id)}}else n.set(c.id,{id:c.id,name:s,type:l,isOwningTheSameRcValueAs:void 0}),r.has(_)||r.set(_,c.id)}}}break;case"FnCall":{if(E(e,V.while)){let s=t.length;Lr(e.func,t,n,r,i,o,e);for(let u of e.args)Lr(u,t,n,r,i,o,e);let l=t.length;if(l>s)for(let u=s;u<l;u++)t[u].isInsideWhile=!0,t[u].whileNestingDepth=(t[u].whileNestingDepth??0)+1,t[u].enclosingWhileExpr||(t[u].enclosingWhileExpr=e);break}if(E(e,V.cond)){hc(e,t,n,r,i,o);break}if(E(e,V.match)){hc(e,t,n,r,i,o);break}if(o.detect(e,a,t),o.shouldSkipBody(e)){if(e.$?.deferredDupExpressions)for(let s of e.$.deferredDupExpressions)Lr(s,t,n,r,i,o,e);break}Lr(e.func,t,n,r,i,o,e);for(let s of e.args)Lr(s,t,n,r,i,o,e);if(e.$?.deferredDropExpressions)for(let s of e.$.deferredDropExpressions)Lr(s,t,n,r,i,o,e);break}}}function hc(e,t,n,r,i,o){if(e.tag!=="FnCall")return;let a=t.length;Lr(e.func,t,n,r,i,o,e);let s=new Map(r),l=[];for(let c of e.args){let _=t.length;Lr(c,t,n,r,i,o,e),l.push(t.slice(_))}r.clear();for(let[c,_]of s)r.set(c,_);let u=Math.max(...l.map(c=>c.length),0);if(u>0){t.splice(a);let c=a;for(let _=0;_<u;_++){let f;for(let p of l)if(_<p.length){f=p[_];break}f&&(f.index=t.length,f.isInsideCond=!0,_===0&&(f.needsOwnCondBranchField=!0),_>0&&(f.condBranchSourceIndex=c),t.push(f))}}}function vc(e){let n=vs(e,{detect(i,o,a){if(i.tag==="FnCall"&&En(i)){let s=i.args[0];if(!s)return;let l=s.$?.type;if(l&&Se(l)){let u=Rt(l);if(!u)return;let c=u.isFuture.outputType,_;if(s.tag==="Atom"&&s.token.type==="identifier"&&s.$){let p=s.token.value,d=K(s.$.env,p);if(d.length>0){let h=d[d.length-1];h.isOwningTheSameRcValueAs?_=h.isOwningTheSameRcValueAs.id:_=h.id}}let f=Xo(o);a.push({index:a.length,expr:i,resultType:c,futureType:u,targetVariableId:f,futureVariableId:_})}}},shouldSkipBody(i){return zt(i)}}),r=n.capturedVariables.map(i=>({id:i.id,name:i.name,type:i.type,kind:"local",isOwningTheSameRcValueAs:void 0}));return{awaitPoints:n.suspensionPoints,capturedVariables:r,hasAwaits:n.hasSuspensions,variableIdRemapping:n.variableIdRemapping}}function zt(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_async"}function En(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_await"}function Tc(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_state"}function Ts(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_spawn"}function Ec(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="join_handle_await"}function Ke(e){return B(e)&&e.token.type==="identifier"||e.token.type==="operator"}function Qo(e,t,n){if(!e.$?.variableName)return;let r=K(t,e.$.variableName);if(!r.length)return;let i=r[r.length-1],o=new Set;for(;i&&i.isOwningTheSameRcValueAs;){if(o.has(i.id))return;o.add(i.id),i=i.isOwningTheSameRcValueAs}if(i&&i.isOwningTheRcValue)return i}function ai(e){let t=e.$?.env;if(!t)return;let n;if(e.$?.pathCollection)for(let r of e.$.pathCollection)r.length>0&&typeof r[0]=="string"&&(n=r[0]);else B(e)&&(n=e.token.value);if(n){let r=K(t,n),i=r[r.length-1];if(i?.isImplicit)throw m({token:e.token,errorMessage:`Cannot use implicit variable "${i.name}" in assignment. Implicit variables must be passed via using() parameters.`})}}var Es=!0;function Cl({variablesToDrop:e,env:t,context:n}){let r=[],i=t;for(let o of e){let a=Qe(`${k.___drop[0]}(${o.name})`),s=x({expr:a,env:i,context:{...n,expectedType:{env:i,type:Q.type}}});r.push(s),s.$&&s.$.env&&(i=s.$.env)}return{deferredDropExpressions:r.length>0?r:void 0,env:i}}function Zo(e,t,n){if(F(e)&&zt(e))return;if(e.$?.deferredDupExpressions)for(let s of e.$.deferredDupExpressions)Zo(s,t,n);if(F(e)&&F(e.func)&&E(e.func,".",2)&&B(e.func.args[0])&&B(e.func.args[1])&&e.func.args[1].token.value===k.___dup[0]&&e.args.length===0&&e.$?.env){let s=e.func.args[0].token.value,l=K(e.$.env,s);if(l.length>0){let u=l[l.length-1];t.has(u.id)||t.set(u.id,[]),t.get(u.id).push(e)}return}if(F(e)&&E(e,V.while))return;function i(s){if(rt(s.$?.controlFlow))return!0;if(F(s)&&E(s,V.begin)){let l=s.args[s.args.length-1];if(rt(l?.$?.controlFlow)||F(l)&&E(l,V.return))return!0}return!!(F(s)&&E(s,V.return))}function o(s){if(F(s)&&E(s,V.tuple,0))return!0;if(F(s)&&E(s,V.begin)){if(s.args.length===0)return!0;if(s.args.length===1){let l=s.args[0];if(F(l)&&E(l,V.tuple,0))return!0}}return!1}function a(s,l){let u=[],c=[],_=[];for(let p=l;p<s.args.length;p++){let d=s.args[p];if(F(d)&&E(d,"=>",2)){let h=d.args[1],g=$c(h);u.push(g),c.push(i(h)),_.push(o(h))}}let f=new Set;for(let p of u){for(let d of p.dupCalls.keys())f.add(d);for(let d of p.varsWithPartialBranchDups)n.add(d)}if(u.length>0)for(let p of f){let d=[],h=[];for(let g=0;g<u.length;g++){let y=u[g],v=y.dupCalls.has(p),T=c[g];if(v){let $=y.dupCalls.get(p);T?d.push(...$):h.push(...$)}}for(let g of d)t.has(p)||t.set(p,[]),g.__isEarlyReturnDup=!0,t.get(p).push(g);if(h.length>0){let g=0,y=0;for(let v=0;v<u.length;v++)c[v]||(g++,u[v].dupCalls.has(p)&&y++);if(y===g){t.has(p)||t.set(p,[]);for(let v of h)t.get(p).push(v)}else n.add(p)}}}if(F(e)&&E(e,V.cond)){a(e,0);return}if(F(e)&&E(e,V.match)){e.args[0]&&Zo(e.args[0],t,n),a(e,1);return}if(F(e)){Zo(e.func,t,n);for(let s of e.args)Zo(s,t,n)}}function $c(e){let t=new Map,n=new Set;return Zo(e,t,n),{dupCalls:t,varsWithPartialBranchDups:n}}function $s(e){return F(e)&&E(e,V.tuple,0)}function bl(e,t){if(e.$?.deferredDupExpressions&&(e.$.deferredDupExpressions=e.$.deferredDupExpressions.filter(n=>!t.has(n)),e.$.deferredDupExpressions.length===0&&(e.$.deferredDupExpressions=void 0)),F(e)){bl(e.func,t);for(let n of e.args)bl(n,t)}}function lg(e,t){let n=new Set,r=e.args;for(let i=0;i<r.length;i++){let o=r[i];if(!F(o)||!E(o,V.while))continue;let a=o.args[o.args.length-1];if(!(!a||!F(a)||!E(a,V.begin)))for(let s of a.args){if(!F(s)||!E(s,V.match))continue;let l=s.args[0];if(!l||!B(l))continue;let u=l.token.value,c,_,f;for(let $=1;$<s.args.length;$++){let b=s.args[$];if(!F(b)||!E(b,"=>",2))continue;let L=b.args[1];if(!(!F(L)||!E(L,V.begin))){for(let C of L.args)if(F(C)&&E(C,"=",2)){let I=C.args[0];if(B(I)&&I.token.value===u){c=C.args[1],_=C,f=L;break}}if(c)break}}if(!c||!_||!f||!c.$?.deferredDupExpressions||c.$.deferredDupExpressions.length===0)continue;let p;for(let $=0;$<i;$++){let b=r[$];if(F(b)&&E(b,"=",2)){let L=b.args[0];if(B(L)&&L.token.value===u){p=b.args[1];break}if(F(L)&&L.args.length>0&&B(L.args[0])&&L.args[0].token.value===u){p=b.args[1];break}}}if(!p)continue;let d=p.$?.variableName;if(!d||!p.$?.env)continue;let h=K(p.$.env,d);if(h.length===0||h[h.length-1].isOwningTheRcValue||!p.$?.deferredDupExpressions||p.$.deferredDupExpressions.length===0)continue;let y=!1;for(let $=i+1;$<r.length;$++)if(kl(r[$],u)){y=!0;break}if(y)continue;p.$.deferredDupExpressions=void 0,c.$.deferredDupExpressions=void 0;let v=_.$?.variableName;v&&f.$?.deferredDropExpressions&&(f.$.deferredDropExpressions=f.$.deferredDropExpressions.filter($=>ug($)!==v),f.$.deferredDropExpressions.length===0&&(f.$.deferredDropExpressions=void 0)),_.$&&(_.$.variableName=void 0);let T=K(t,u);if(T.length>0){let $=T[T.length-1];t=qe(t,$,{...$,consumedAtToken:$.token})}n.add(u)}}return{optimizedVarNames:n,env:t}}function ug(e){if(F(e)&&e.args.length===0&&F(e.func)&&E(e.func,".",2)&&B(e.func.args[1])&&e.func.args[1].token.value===k.___drop[0]&&B(e.func.args[0]))return e.func.args[0].token.value;if(F(e)&&E(e,k.___drop)&&e.args.length>=1&&B(e.args[0]))return e.args[0].token.value}function kl(e,t){if(B(e)&&e.token.value===t)return!0;if(F(e)){if(kl(e.func,t))return!0;for(let n of e.args)if(kl(n,t))return!0}return!1}function vt({expr:e,env:t,context:n,variablesToAdd:r=[],isEvaluatingFunctionBodyBeginBlock:i=!1}){if(F(e)&&E(e,"_")&&!E(e,V.begin)){let L=e;L.args.some(I=>F(I)&&E(I,":"))||(L.func={...L.func,token:{...L.func.token,value:V.begin[0]}})}if(!F(e)||!E(e,V.begin)){let L={tag:"FnCall",func:{tag:"Atom",token:{...e.token,value:V.begin[0]}},args:[Me(e)],token:{...e.token,value:V.begin[0]}};wr(e,L),e=e}let o=e.args,a=n.expectedType;if(o.length===0)return e.$={env:t,type:Q.type,value:Q,pathCollection:[]},e;t=Ve(t,void 0,!0);for(let L=0;L<r.length;L++){let C=r[L],{env:I}=fe({env:t,variable:C});t=I}let s=o[o.length-1],l,u=!1;for(let L=0;L<o.length;L++){let C=o[L];if(B(C)&&ht(C,V.return)||F(C)&&E(C,V.return)){if(L!==o.length-1&&!(L===o.length-2&&$s(o[o.length-1])))throw m({token:C.token,errorMessage:'The "return" keyword can only be used as the last expression.'});if(F(C)&&he(C,V.return,1),!n.isEvaluatingFunctionBodyOrAsyncBlock)throw m({token:C.token,errorMessage:'The "return" keyword can only be used inside a function body or async block.'});if(l=C,B(C)){C.$={env:t,type:Q.type,value:Q,pathCollection:[],controlFlow:ii("return")},s=C;break}else{he(C,V.return,1);let I=C.args[0],A=x({expr:I,env:t,context:{...n,expectedType:n.isEvaluatingFunctionBodyOrAsyncBlock.kind==="function-body"?{type:n.isEvaluatingFunctionBodyOrAsyncBlock.type.return.type,env:t}:n.expectedType}});if(!A.$)throw m({token:I.token,errorMessage:`Return expression is not evaluated correctly:
+`),inner:!0,position:r,modulePath:i}),t}function yc(e,t){let n=t;for(;n<e.length;){let r=e[n];if(sg(r)||og(r)){n++;continue}if(r.type==="identifier")return{name:r.value,position:r.position};if(r.type==="("){n++;continue}return{name:"",position:null}}return{name:"",position:null}}function gs(e){return E(e,["->","=>"])?!!(e.$?.isAnonymousFunctionDefinition===!0||e.$?.value!==void 0&&ne(e.$.value)||F(e)&&F(e.func)&&(E(e.func,V.fn)||E(e.func,V.unsafe_fn)||E(e.func,V.Fn))||!e.$):!1}function hs(e,t){if(!F(e))return!1;if(t(e.func))return!0;for(let n of e.args)if(F(n)&&E(n,"=>")){for(let r of n.args)if(t(r))return!0}else if(t(n))return!0;return!1}function cr(e){if(B(e))return ht(e,V.escape);if(F(e)){if(e.$?.macroExpansion)return cr(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,cr);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(cr(e.func))return!0;for(let t of e.args)if(cr(t))return!0}return!1}function uo(e){if(B(e))return ht(e,V.return)||ht(e,V.escape);if(F(e)){if(E(e,V.return)||E(e,V.escape))return!0;if(e.$?.macroExpansion)return uo(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,uo);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(uo(e.func))return!0;for(let t of e.args)if(uo(t))return!0}return!1}function pn(e){if(F(e)){if(e.func.$?.type?.ioBuiltin==="io_await")return!0;if(e.$?.macroExpansion)return pn(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,pn);if(e.func.$?.type?.ioBuiltin==="io_async"||gs(e)||O(e.func.$?.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(pn(e.func))return!0;for(let t of e.args)if(pn(t))return!0}return!1}function co(e){if(B(e))return ht(e,V.break)||ht(e,V.return)||ht(e,V.escape);if(F(e)){if(E(e,V.return)||E(e,V.escape))return!0;if(e.$?.macroExpansion)return co(e.$.macroExpansion);if(E(e,V.cond)||E(e,V.match))return hs(e,co);if(gs(e)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&W(e.func.$.value.value)||F(e.func)&&e.func.$?.value!==void 0&&O(e.func.$.value)&&Zt(e.func.$.value.value))return!1;if(co(e.func))return!0;for(let t of e.args)if(co(t))return!0}return!1}var Q={tag:"Unit",type:Yn()};function Xo(e){if(e&&e.tag==="FnCall"&&E(e,":=")){let t=e.args[0];if(t&&t.tag==="Atom"&&t.token.type==="identifier"&&t.$){let n=t.token.value,r=K(t.$.env,n);if(r.length>0)return r[r.length-1].id}}}function vs(e,t){let n=[],r=new Map,i=new Map,o=new Map;if(Lr(e,n,r,i,o,t),e.$?.deferredDropExpressions)for(let a of e.$.deferredDropExpressions)Lr(a,n,r,i,o,t);return n.length===0&&r.clear(),{suspensionPoints:n,capturedVariables:Array.from(r.values()),hasSuspensions:n.length>0,variableIdRemapping:o}}function Lr(e,t,n,r,i,o,a){switch(e.tag){case"Atom":if(e.$&&e.token.type==="identifier"){let s=e.token.value,l=e.$.type,u=K(e.$.env,s);if(u.length>0){let c=u[u.length-1];if(c&&!n.has(c.id)&&!c.isCompileTimeOnly){let _=`${c.name}:${c.frameLevel}`,f=r.get(_);if(f&&f!==c.id)i.set(c.id,f);else if(c.isOwningTheSameRcValueAs){let p=c.isOwningTheSameRcValueAs;if(!n.has(p.id)){let d={id:p.id,name:p.name,type:p.type,isOwningTheSameRcValueAs:void 0};n.set(p.id,d);let h=`${p.name}:${p.frameLevel}`;r.has(h)||r.set(h,p.id)}}else n.set(c.id,{id:c.id,name:s,type:l,isOwningTheSameRcValueAs:void 0}),r.has(_)||r.set(_,c.id)}}}break;case"FnCall":{if(E(e,V.while)){let s=t.length;Lr(e.func,t,n,r,i,o,e);for(let u of e.args)Lr(u,t,n,r,i,o,e);let l=t.length;if(l>s)for(let u=s;u<l;u++)t[u].isInsideWhile=!0,t[u].whileNestingDepth=(t[u].whileNestingDepth??0)+1,t[u].enclosingWhileExpr||(t[u].enclosingWhileExpr=e);break}if(E(e,V.cond)){hc(e,t,n,r,i,o);break}if(E(e,V.match)){hc(e,t,n,r,i,o);break}if(o.detect(e,a,t),o.shouldSkipBody(e)){if(e.$?.deferredDupExpressions)for(let s of e.$.deferredDupExpressions)Lr(s,t,n,r,i,o,e);break}Lr(e.func,t,n,r,i,o,e);for(let s of e.args)Lr(s,t,n,r,i,o,e);if(e.$?.deferredDropExpressions)for(let s of e.$.deferredDropExpressions)Lr(s,t,n,r,i,o,e);break}}}function hc(e,t,n,r,i,o){if(e.tag!=="FnCall")return;let a=t.length;Lr(e.func,t,n,r,i,o,e);let s=new Map(r),l=[];for(let c of e.args){let _=t.length;Lr(c,t,n,r,i,o,e),l.push(t.slice(_))}r.clear();for(let[c,_]of s)r.set(c,_);let u=Math.max(...l.map(c=>c.length),0);if(u>0){t.splice(a);let c=a;for(let _=0;_<u;_++){let f;for(let p of l)if(_<p.length){f=p[_];break}f&&(f.index=t.length,f.isInsideCond=!0,_===0&&(f.needsOwnCondBranchField=!0),_>0&&(f.condBranchSourceIndex=c),t.push(f))}}}function vc(e){let n=vs(e,{detect(i,o,a){if(i.tag==="FnCall"&&En(i)){let s=i.args[0];if(!s)return;let l=s.$?.type;if(l&&Se(l)){let u=Rt(l);if(!u)return;let c=u.isFuture.outputType,_;if(s.tag==="Atom"&&s.token.type==="identifier"&&s.$){let p=s.token.value,d=K(s.$.env,p);if(d.length>0){let h=d[d.length-1];h.isOwningTheSameRcValueAs?_=h.isOwningTheSameRcValueAs.id:_=h.id}}let f=Xo(o);a.push({index:a.length,expr:i,resultType:c,futureType:u,targetVariableId:f,futureVariableId:_})}}},shouldSkipBody(i){return zt(i)}}),r=n.capturedVariables.map(i=>({id:i.id,name:i.name,type:i.type,kind:"local",isOwningTheSameRcValueAs:void 0}));return{awaitPoints:n.suspensionPoints,capturedVariables:r,hasAwaits:n.hasSuspensions,variableIdRemapping:n.variableIdRemapping}}function zt(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_async"}function En(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_await"}function Tc(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_state"}function Ts(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="io_spawn"}function Ec(e){return e.tag!=="FnCall"?!1:e.func.$?.type?.ioBuiltin==="join_handle_await"}function Ke(e){return B(e)&&e.token.type==="identifier"||e.token.type==="operator"}function Qo(e,t,n){if(!e.$?.variableName)return;let r=K(t,e.$.variableName);if(!r.length)return;let i=r[r.length-1],o=new Set;for(;i&&i.isOwningTheSameRcValueAs;){if(o.has(i.id))return;o.add(i.id),i=i.isOwningTheSameRcValueAs}if(i&&i.isOwningTheRcValue)return i}function ai(e){let t=e.$?.env;if(!t)return;let n;if(e.$?.pathCollection)for(let r of e.$.pathCollection)r.length>0&&typeof r[0]=="string"&&(n=r[0]);else B(e)&&(n=e.token.value);if(n){let r=K(t,n),i=r[r.length-1];if(i?.isImplicit)throw m({token:e.token,errorMessage:`Cannot use implicit variable "${i.name}" in assignment. Implicit variables must be passed via using() parameters.`})}}var Es=!0;function Cl({variablesToDrop:e,env:t,context:n}){let r=[],i=t;for(let o of e){let a=Qe(`${k.___drop[0]}(${o.name})`),s=x({expr:a,env:i,context:{...n,expectedType:{env:i,type:Q.type}}});r.push(s),s.$&&s.$.env&&(i=s.$.env)}return{deferredDropExpressions:r.length>0?r:void 0,env:i}}function Zo(e,t,n){if(F(e)&&zt(e))return;if(e.$?.deferredDupExpressions)for(let s of e.$.deferredDupExpressions)Zo(s,t,n);if(F(e)&&F(e.func)&&E(e.func,".",2)&&B(e.func.args[0])&&B(e.func.args[1])&&e.func.args[1].token.value===k.___dup[0]&&e.args.length===0&&e.$?.env){let s=e.func.args[0].token.value,l=K(e.$.env,s);if(l.length>0){let u=l[l.length-1];t.has(u.id)||t.set(u.id,[]),t.get(u.id).push(e)}return}if(F(e)&&E(e,V.while))return;function i(s){if(rt(s.$?.controlFlow))return!0;if(F(s)&&E(s,V.begin)){let l=s.args[s.args.length-1];if(rt(l?.$?.controlFlow)||F(l)&&E(l,V.return))return!0}return!!(F(s)&&E(s,V.return))}function o(s){if(F(s)&&E(s,V.tuple,0))return!0;if(F(s)&&E(s,V.begin)){if(s.args.length===0)return!0;if(s.args.length===1){let l=s.args[0];if(F(l)&&E(l,V.tuple,0))return!0}}return!1}function a(s,l){let u=[],c=[],_=[];for(let p=l;p<s.args.length;p++){let d=s.args[p];if(F(d)&&E(d,"=>",2)){let h=d.args[1],g=$c(h);u.push(g),c.push(i(h)),_.push(o(h))}}let f=new Set;for(let p of u){for(let d of p.dupCalls.keys())f.add(d);for(let d of p.varsWithPartialBranchDups)n.add(d)}if(u.length>0)for(let p of f){let d=[],h=[];for(let g=0;g<u.length;g++){let y=u[g],v=y.dupCalls.has(p),T=c[g];if(v){let $=y.dupCalls.get(p);T?d.push(...$):h.push(...$)}}for(let g of d)t.has(p)||t.set(p,[]),g.__isEarlyReturnDup=!0,t.get(p).push(g);if(h.length>0){let g=0,y=0;for(let v=0;v<u.length;v++)c[v]||(g++,u[v].dupCalls.has(p)&&y++);if(y===g){t.has(p)||t.set(p,[]);for(let v of h)t.get(p).push(v)}else n.add(p)}}}if(F(e)&&E(e,V.cond)){a(e,0);return}if(F(e)&&E(e,V.match)){e.args[0]&&Zo(e.args[0],t,n),a(e,1);return}if(F(e)){Zo(e.func,t,n);for(let s of e.args)Zo(s,t,n)}}function $c(e){let t=new Map,n=new Set;return Zo(e,t,n),{dupCalls:t,varsWithPartialBranchDups:n}}function $s(e){return F(e)&&E(e,V.tuple,0)}function bl(e,t){if(e.$?.deferredDupExpressions&&(e.$.deferredDupExpressions=e.$.deferredDupExpressions.filter(n=>!t.has(n)),e.$.deferredDupExpressions.length===0&&(e.$.deferredDupExpressions=void 0)),F(e)){bl(e.func,t);for(let n of e.args)bl(n,t)}}function lg(e,t){let n=new Set,r=e.args;for(let i=0;i<r.length;i++){let o=r[i];if(!F(o)||!E(o,V.while))continue;let a=o.args[o.args.length-1];if(!(!a||!F(a)||!E(a,V.begin)))for(let s of a.args){if(!F(s)||!E(s,V.match))continue;let l=s.args[0];if(!l||!B(l))continue;let u=l.token.value,c,_,f;for(let $=1;$<s.args.length;$++){let b=s.args[$];if(!F(b)||!E(b,"=>",2))continue;let L=b.args[1];if(!(!F(L)||!E(L,V.begin))){for(let C of L.args)if(F(C)&&E(C,"=",2)){let I=C.args[0];if(B(I)&&I.token.value===u){c=C.args[1],_=C,f=L;break}}if(c)break}}if(!c||!_||!f||!c.$?.deferredDupExpressions||c.$.deferredDupExpressions.length===0)continue;let p;for(let $=0;$<i;$++){let b=r[$];if(F(b)&&E(b,"=",2)){let L=b.args[0];if(B(L)&&L.token.value===u){p=b.args[1];break}if(F(L)&&L.args.length>0&&B(L.args[0])&&L.args[0].token.value===u){p=b.args[1];break}}}if(!p)continue;let d=p.$?.variableName;if(!d||!p.$?.env)continue;let h=K(p.$.env,d);if(h.length===0||h[h.length-1].isOwningTheRcValue||!p.$?.deferredDupExpressions||p.$.deferredDupExpressions.length===0)continue;let y=!1;for(let $=i+1;$<r.length;$++)if(kl(r[$],u)){y=!0;break}if(y)continue;p.$.deferredDupExpressions=void 0,c.$.deferredDupExpressions=void 0;let v=_.$?.variableName;v&&f.$?.deferredDropExpressions&&(f.$.deferredDropExpressions=f.$.deferredDropExpressions.filter($=>ug($)!==v),f.$.deferredDropExpressions.length===0&&(f.$.deferredDropExpressions=void 0)),_.$&&(_.$.variableName=void 0);let T=K(t,u);if(T.length>0){let $=T[T.length-1];t=qe(t,$,{...$,consumedAtToken:$.token})}n.add(u)}}return{optimizedVarNames:n,env:t}}function ug(e){if(F(e)&&e.args.length===0&&F(e.func)&&E(e.func,".",2)&&B(e.func.args[1])&&e.func.args[1].token.value===k.___drop[0]&&B(e.func.args[0]))return e.func.args[0].token.value;if(F(e)&&E(e,k.___drop)&&e.args.length>=1&&B(e.args[0]))return e.args[0].token.value}function kl(e,t){if(B(e)&&e.token.value===t)return!0;if(F(e)){if(kl(e.func,t))return!0;for(let n of e.args)if(kl(n,t))return!0}return!1}function vt({expr:e,env:t,context:n,variablesToAdd:r=[],isEvaluatingFunctionBodyBeginBlock:i=!1}){if(F(e)&&E(e,"_")&&!E(e,V.begin)){let L=e;L.args.some(I=>F(I)&&E(I,":"))||(L.func={...L.func,token:{...L.func.token,value:V.begin[0]}})}if(!F(e)||!E(e,V.begin)){let L={tag:"FnCall",func:{tag:"Atom",token:{...e.token,value:V.begin[0]}},args:[Me(e)],token:{...e.token,value:V.begin[0]}};wr(e,L),e=e}let o=e.args,a=n.expectedType;if(o.length===0)return e.$={env:t,type:Q.type,value:Q,pathCollection:[]},e;t=Ve(t,void 0,!0);for(let L=0;L<r.length;L++){let C=r[L],{env:I}=fe({env:t,variable:C});t=I}let s=o[o.length-1],l,u=!1;for(let L=0;L<o.length;L++){let C=o[L];if(B(C)&&ht(C,V.return)||F(C)&&E(C,V.return)){if(L!==o.length-1&&!(L===o.length-2&&$s(o[o.length-1])))throw m({token:C.token,errorMessage:'The "return" keyword can only be used as the last expression.'});if(F(C)&&he(C,V.return,1),!n.isEvaluatingFunctionBodyOrAsyncBlock)throw m({token:C.token,errorMessage:'The "return" keyword can only be used inside a function body or async block.'});if(l=C,B(C)){C.$={env:t,type:Q.type,value:Q,pathCollection:[],controlFlow:ii("return")},s=C;break}else{he(C,V.return,1);let I=C.args[0],A=x({expr:I,env:t,context:{...n,expectedType:n.isEvaluatingFunctionBodyOrAsyncBlock.kind==="function-body"?{type:n.isEvaluatingFunctionBodyOrAsyncBlock.type.return.type,env:t}:n.expectedType}});if(!A.$)throw m({token:I.token,errorMessage:`Return expression is not evaluated correctly:
 ${w(I)}`});if(n.isEvaluatingFunctionBodyOrAsyncBlock?.kind==="function-body"&&D(n.isEvaluatingFunctionBodyOrAsyncBlock.type.return.type)&&n.functionReturnImplConcreteType){let z=A.$.type;if(n.functionReturnImplConcreteType.length>0){let P=n.functionReturnImplConcreteType[0];if(!X({type:P.concreteType,env:P.env},{type:z,env:t}))throw ct([{token:C.token,errorMessage:`All return statements must return the same concrete type for Impl(...).
 Impl(...) uses static dispatch and requires the same concrete type across all returns.
 Consider using Dyn(...) for dynamic dispatch if different concrete types are needed.`},{token:P.token,errorMessage:`First return has concrete type: ${S(P.concreteType)}`},{token:C.token,errorMessage:`Conflicting return has concrete type: ${S(z)}`}])}else n.functionReturnImplConcreteType.push({concreteType:z,env:t,token:C.token})}He(A,!0),t=A.$.env,C.$={env:t,type:A.$.type,value:A.$.value,pathCollection:A.$.pathCollection,variableName:A.$.variableName,controlFlow:ii("return")},s=C;break}}else if(B(C)&&ht(C,V.break)){if(L!==o.length-1&&!(L===o.length-2&&$s(o[o.length-1])))throw m({token:C.token,errorMessage:'The "break" keyword can only be used as the last expression.'});if(!n.isEvaluatingLoopBody)throw m({token:C.token,errorMessage:'The "break" keyword can only be used inside a loop.'});C.$={env:t,type:Q.type,value:Q,pathCollection:[],controlFlow:ii("break")},s=C;break}else if(B(C)&&ht(C,V.continue)){if(L!==o.length-1&&!(L===o.length-2&&$s(o[o.length-1])))throw m({token:C.token,errorMessage:'The "continue" keyword can only be used as the last expression.'});if(!n.isEvaluatingLoopBody)throw m({token:C.token,errorMessage:'The "continue" keyword can only be used inside a loop.'});C.$={env:t,type:Q.type,value:Q,pathCollection:[],controlFlow:ii("continue")},s=C;break}else if(F(C)&&E(C,V.escape)){if(L!==o.length-1&&!(L===o.length-2&&$s(o[o.length-1])))throw m({token:C.token,errorMessage:'The "escape" keyword can only be used as the last expression.'});if(!n.enclosingFunctionReturnType)throw m({token:C.token,errorMessage:'The "escape" keyword can only be used inside a function that has an enclosing function.'});l=C,he(C,V.escape,1);let I=C.args[0],A=x({expr:I,env:t,context:{...n,expectedType:{type:n.enclosingFunctionReturnType,env:t}}});if(!A.$)throw m({token:I.token,errorMessage:`Escape expression is not evaluated correctly:
@@ -228,7 +228,11 @@ typedef struct {
 } __yo_async_task_queue_t;
 
 // Thread-local async runtime state
-${Bt(t)?"static __declspec(thread) __yo_async_task_queue_t __yo_thread_async_queue = {NULL, NULL, 0};":"static __thread __yo_async_task_queue_t __yo_thread_async_queue = {NULL, NULL, 0};"}
+${Bt(t)?`static __declspec(thread) __yo_async_task_queue_t __yo_thread_async_queue = {NULL, NULL, 0};
+// Free-list of reusable continuation nodes to avoid per-completion malloc/free.
+static __declspec(thread) __yo_continuation_t* __yo_cont_free_list = NULL;`:`static __thread __yo_async_task_queue_t __yo_thread_async_queue = {NULL, NULL, 0};
+// Free-list of reusable continuation nodes to avoid per-completion malloc/free.
+static __thread __yo_continuation_t* __yo_cont_free_list = NULL;`}
 
 // Async scheduler initialized flag (per-thread \u2014 each thread has its own event loop)
 static ${r} bool __yo_async_scheduler_initialized = false;
@@ -260,12 +264,18 @@ static void __yo_async_scheduler_init(void) {
 // Use __yo_async_spawn_task for spawning tasks with proper lifetime management.
 static void __yo_async_enqueue_continuation(void (*resume_fn)(void*), void* state_machine) {
   ASYNC_DEBUG("[ASYNC] Enqueueing continuation: resume_fn=%p, sm=%p\\n", (void*)resume_fn, state_machine);
-  
-  __yo_continuation_t* cont = (__yo_continuation_t*)__yo_malloc(sizeof(__yo_continuation_t));
+
+  __yo_continuation_t* cont;
+  if (__yo_cont_free_list) {
+    cont = __yo_cont_free_list;
+    __yo_cont_free_list = cont->next;
+  } else {
+    cont = (__yo_continuation_t*)__yo_malloc(sizeof(__yo_continuation_t));
+  }
   cont->resume_fn = resume_fn;
   cont->state_machine = state_machine;
   cont->next = NULL;
-  
+
   if (__yo_thread_async_queue.tail) {
     __yo_thread_async_queue.tail->next = cont;
     __yo_thread_async_queue.tail = cont;
@@ -273,7 +283,7 @@ static void __yo_async_enqueue_continuation(void (*resume_fn)(void*), void* stat
     __yo_thread_async_queue.head = cont;
     __yo_thread_async_queue.tail = cont;
   }
-  
+
   __yo_thread_async_queue.count++;
   ASYNC_DEBUG("[ASYNC] Queue count: %zu\\n", __yo_thread_async_queue.count);
 }
@@ -299,7 +309,9 @@ static void __yo_async_run_ready_tasks(void) {
     }
     __yo_thread_async_queue.count--;
     cont->resume_fn(cont->state_machine);
-    __yo_free(cont);
+    // Return the node to the free-list instead of freeing it.
+    cont->next = __yo_cont_free_list;
+    __yo_cont_free_list = cont;
   }
 }
 
@@ -344,7 +356,9 @@ static void __yo_async_run_until_complete(void* future_ptr) {
                   (void*)cont->resume_fn, cont->state_machine, __yo_thread_async_queue.count);
       
       cont->resume_fn(cont->state_machine);
-      __yo_free(cont);
+      // Return the node to the free-list instead of freeing it.
+      cont->next = __yo_cont_free_list;
+      __yo_cont_free_list = cont;
       tasks_run++;
     }
     
@@ -373,6 +387,13 @@ static void __yo_async_run_until_complete(void* future_ptr) {
   
   __yo_io_cleanup();
   
+  // Free the continuation node free-list so worker threads don't leak.
+  while (__yo_cont_free_list) {
+    __yo_continuation_t* node = __yo_cont_free_list;
+    __yo_cont_free_list = node->next;
+    __yo_free(node);
+  }
+  
   ASYNC_DEBUG("[ASYNC] Event loop finished, future state=%d\\n", future->state);
   
   if (future->state == -2) {
@@ -422,6 +443,13 @@ static void __yo_async_wait_all(void) {
     }
   }
   
+  // Free the continuation node free-list so worker threads don't leak.
+  while (__yo_cont_free_list) {
+    __yo_continuation_t* node = __yo_cont_free_list;
+    __yo_cont_free_list = node->next;
+    __yo_free(node);
+  }
+  
   ASYNC_DEBUG("[ASYNC] All tasks completed\\n");
 }
 
@@ -1047,6 +1075,17 @@ static _Thread_local int __yo_io_kq = -1;
 // __yo_io_initialized is defined in runtime-core
 static _Thread_local size_t __yo_pending_io_count = 0;  // per-thread event loop counter
 
+// Batched kevent changelist. Instead of issuing one kevent() syscall per
+// I/O op to register EVFILT_READ/EVFILT_WRITE, we append changes to a
+// thread-local array and submit them in bulk as part of the kevent() call
+// in __yo_io_poll / __yo_io_wait. This is the kqueue analogue of deferred
+// io_uring submission on Linux and batched GetQueuedCompletionStatusEx on
+// Windows. Size = 64 matches the events[] buffer so EV_ERROR packets
+// always fit alongside the reaped events.
+#define __YO_KQ_CHANGES_MAX 64
+static _Thread_local struct kevent __yo_kq_changes[__YO_KQ_CHANGES_MAX];
+static _Thread_local size_t __yo_kq_n_changes = 0;
+
 // Pending operation types for kqueue completion dispatch
 typedef enum {
   __YO_IO_OP_READ,
@@ -1075,6 +1114,43 @@ typedef struct __yo_io_pending_op_t {
   };
 } __yo_io_pending_op_t;
 
+// Per-thread free list for __yo_io_pending_op_t to eliminate malloc/free
+// per async I/O op. The first sizeof(void*) bytes are overlaid with a
+// 'next' pointer when the struct sits on the free list; allocation sites
+// fully re-initialize all fields they care about (op, future, and the
+// active union arm), so trampling the front of the struct is safe.
+static _Thread_local __yo_io_pending_op_t* __yo_io_pending_free_list = NULL;
+
+static inline __yo_io_pending_op_t* __yo_kq_alloc_pending(void) {
+  if (__yo_io_pending_free_list) {
+    __yo_io_pending_op_t* p = __yo_io_pending_free_list;
+    __yo_io_pending_free_list = *(__yo_io_pending_op_t**)p;
+    return p;
+  }
+  return (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+}
+
+static inline void __yo_kq_free_pending(__yo_io_pending_op_t* p) {
+  if (!p) return;
+  *(__yo_io_pending_op_t**)p = __yo_io_pending_free_list;
+  __yo_io_pending_free_list = p;
+}
+
+// Forward declaration \u2014 defined after __yo_io_init
+static void __yo_io_wake_continuation(__yo_io_future_t* future);
+
+static inline void __yo_kq_cancel_pending(__yo_io_pending_op_t* pending, int err, bool wake) {
+  if (!pending) return;
+  pending->future->result = -err;
+  __yo_pending_io_count--;
+  if (wake) {
+    __yo_io_wake_continuation(pending->future);
+  } else {
+    atomic_store_explicit(&pending->future->state, -1, memory_order_release);
+  }
+  __yo_kq_free_pending(pending);
+}
+
 // Initialize kqueue subsystem
 static void __yo_io_init(void) {
   if (__yo_io_initialized) return;
@@ -1091,7 +1167,13 @@ static void __yo_io_init(void) {
 // Cleanup kqueue
 static void __yo_io_cleanup(void) {
   if (!__yo_io_initialized) return;
-  
+  // If async main returns while registrations are still only queued in the
+  // deferred changelist, cancel them explicitly instead of dropping them on
+  // close(kqueue).
+  for (size_t i = 0; i < __yo_kq_n_changes; i++) {
+    __yo_kq_cancel_pending((__yo_io_pending_op_t*)__yo_kq_changes[i].udata, ECANCELED, false);
+  }
+  __yo_kq_n_changes = 0;
   if (__yo_io_kq >= 0) {
     close(__yo_io_kq);
     __yo_io_kq = -1;
@@ -1197,26 +1279,86 @@ static void __yo_io_process_event(struct kevent* ev) {
   
   __yo_pending_io_count--;
   __yo_io_wake_continuation(future);
-  __yo_free(pending);
+  __yo_kq_free_pending(pending);
+}
+
+// Flush any queued kevent changes to the kernel synchronously. Called when
+// the deferred changelist is full, or just before tearing down. Normal
+// flow amortizes changes into the next kevent() reap call in poll/wait.
+static void __yo_kq_flush_changes(void) {
+  if (__yo_kq_n_changes == 0) return;
+  struct kevent err_events[__YO_KQ_CHANGES_MAX];
+  int nchanges = (int)__yo_kq_n_changes;
+  int n;
+  do {
+    n = kevent(__yo_io_kq, __yo_kq_changes, nchanges,
+               err_events, __YO_KQ_CHANGES_MAX, NULL);
+  } while (n < 0 && errno == EINTR);
+  // On a true syscall failure (e.g., EBADF), the changelist was not processed.
+  // Surface each queued op as an error so counters/free list stay balanced.
+  if (n < 0) {
+    int err = errno;
+    for (int i = 0; i < nchanges; i++) {
+      __yo_kq_cancel_pending((__yo_io_pending_op_t*)__yo_kq_changes[i].udata, err, true);
+    }
+    __yo_kq_n_changes = 0;
+    return;
+  }
+  __yo_kq_n_changes = 0;
+  for (int i = 0; i < n; i++) {
+    // EV_ERROR entries report per-change registration failures.
+    if (err_events[i].flags & EV_ERROR) {
+      __yo_kq_cancel_pending((__yo_io_pending_op_t*)err_events[i].udata, (int)err_events[i].data, true);
+    } else {
+      __yo_io_process_event(&err_events[i]);
+    }
+  }
 }
 
 // Process completions (non-blocking poll)
 static int __yo_io_poll(void) {
   struct kevent events[64];
   struct timespec ts = {0, 0};  // non-blocking
-  int n = kevent(__yo_io_kq, NULL, 0, events, 64, &ts);
-  
+
+  // Submit any pending changes atomically with the reap syscall.
+  int nchanges = (int)__yo_kq_n_changes;
+  int n;
+  do {
+    n = kevent(__yo_io_kq, __yo_kq_changes, nchanges, events, 64, &ts);
+  } while (n < 0 && errno == EINTR);
+  // Only clear the changelist if kevent accepted it (n >= 0). On hard
+  // failure, surface each queued op so we do not leak pending_ops or
+  // desync __yo_pending_io_count.
+  if (n < 0) {
+    int err = errno;
+    for (int i = 0; i < nchanges; i++) {
+      __yo_kq_cancel_pending((__yo_io_pending_op_t*)__yo_kq_changes[i].udata, err, true);
+    }
+    __yo_kq_n_changes = 0;
+    return __yo_poll_and_fs_event_tick();
+  }
+  __yo_kq_n_changes = 0;
+
+  int processed = 0;
   for (int i = 0; i < n; i++) {
+    if (events[i].flags & EV_ERROR) {
+      if (events[i].udata) {
+        __yo_kq_cancel_pending((__yo_io_pending_op_t*)events[i].udata, (int)events[i].data, true);
+        processed++;
+      }
+      continue;
+    }
     __yo_io_process_event(&events[i]);
+    processed++;
   }
-  
-  if (n > 0) {
-    ASYNC_DEBUG("[IO] Polled %d kqueue completions\\n", n);
+
+  if (processed > 0) {
+    ASYNC_DEBUG("[IO] Polled %d kqueue completions\\n", processed);
   }
-  
+
   // Also tick poll/fs_event handles
   int extra = __yo_poll_and_fs_event_tick();
-  return (n > 0 ? n : 0) + extra;
+  return processed + extra;
 }
 
 // Wait for at least one I/O completion (blocking)
@@ -1227,30 +1369,61 @@ static int __yo_io_wait(void) {
     nanosleep(&ts, NULL);
     return __yo_poll_and_fs_event_tick();
   }
-  if (__yo_pending_io_count == 0) return 0;
-  
+  if (__yo_pending_io_count == 0) {
+    // Defensive: if we have deferred changes but nothing pending, flush
+    // them so they do not sit indefinitely (rare -- registration bumps
+    // __yo_pending_io_count, so this should normally be a no-op).
+    if (__yo_kq_n_changes > 0) __yo_kq_flush_changes();
+    return 0;
+  }
+
   struct kevent events[64];
   struct timespec timeout = {0, 100 * 1000 * 1000};  // 100ms timeout
-  int n = kevent(__yo_io_kq, NULL, 0, events, 64, &timeout);
-  
+
+  // Submit any pending changes atomically with the blocking wait. This
+  // turns N registration syscalls + 1 wait syscall into a single syscall.
+  int nchanges = (int)__yo_kq_n_changes;
+  int n;
+  do {
+    n = kevent(__yo_io_kq, __yo_kq_changes, nchanges, events, 64, &timeout);
+  } while (n < 0 && errno == EINTR);
+  if (n < 0) {
+    int err = errno;
+    for (int i = 0; i < nchanges; i++) {
+      __yo_kq_cancel_pending((__yo_io_pending_op_t*)__yo_kq_changes[i].udata, err, true);
+    }
+    __yo_kq_n_changes = 0;
+    return 0;
+  }
+  __yo_kq_n_changes = 0;
+
+  int processed = 0;
   for (int i = 0; i < n; i++) {
+    if (events[i].flags & EV_ERROR) {
+      if (events[i].udata) {
+        __yo_kq_cancel_pending((__yo_io_pending_op_t*)events[i].udata, (int)events[i].data, true);
+        processed++;
+      }
+      continue;
+    }
     __yo_io_process_event(&events[i]);
+    processed++;
   }
-  
-  return (n > 0) ? n : 0;
+
+  return processed;
 }
 
-// Helper to register a kevent and track the pending operation
+// Queue a kevent change onto the per-thread deferred changelist. The
+// actual kevent() syscall is amortized into the next poll/wait call \u2014
+// see __yo_kq_flush_changes / __yo_io_poll / __yo_io_wait. If the
+// changelist is full we flush synchronously to make room.
 static void __yo_io_register_kevent(__yo_io_pending_op_t* pending, int fd, int16_t filter) {
-  struct kevent ev;
-  EV_SET(&ev, fd, filter, EV_ADD | EV_ONESHOT, 0, 0, (void*)pending);
-  if (kevent(__yo_io_kq, &ev, 1, NULL, 0, NULL) < 0) {
-    // Registration failed \u2014 complete immediately with error
-    pending->future->result = -errno;
-    __yo_io_wake_continuation(pending->future);
-    __yo_free(pending);
-    return;
+  if (__yo_kq_n_changes >= __YO_KQ_CHANGES_MAX) {
+    __yo_kq_flush_changes();
   }
+  EV_SET(&__yo_kq_changes[__yo_kq_n_changes], fd, filter,
+         EV_ADD | EV_ONESHOT, 0, 0, (void*)pending);
+  __yo_kq_n_changes++;
   __yo_pending_io_count++;
 }
 
@@ -1293,7 +1466,7 @@ static __yo_io_future_t* __yo_async_read_start(int32_t fd, void* buffer, uint32_
   }
   
   // Would block \u2014 register kevent(EVFILT_READ) for readability notification
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_READ;
   pending->future = future;
   pending->read.fd = fd;
@@ -1354,7 +1527,7 @@ static __yo_io_future_t* __yo_async_write_start(int32_t fd, const void* buffer,
   }
   
   // Would block \u2014 register kevent(EVFILT_WRITE) for writability notification
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_WRITE;
   pending->future = future;
   pending->write.fd = fd;
@@ -1750,7 +1923,7 @@ static __yo_io_future_t* __yo_async_accept_start(int32_t sockfd, void* addr, uin
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_ACCEPT;
   pending->future = future;
   pending->accept.fd = sockfd;
@@ -1794,7 +1967,7 @@ static __yo_io_future_t* __yo_async_connect_start(int32_t sockfd, const void* ad
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_CONNECT;
   pending->future = future;
   pending->connect.fd = sockfd;
@@ -1836,7 +2009,7 @@ static __yo_io_future_t* __yo_async_send_start(int32_t sockfd, const void* buf,
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_SEND;
   pending->future = future;
   pending->send.fd = sockfd;
@@ -1881,7 +2054,7 @@ static __yo_io_future_t* __yo_async_recv_start(int32_t sockfd, void* buf, size_t
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_RECV;
   pending->future = future;
   pending->recv.fd = sockfd;
@@ -1927,7 +2100,7 @@ static __yo_io_future_t* __yo_async_sendto_start(int32_t sockfd, const void* buf
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_SENDTO;
   pending->future = future;
   pending->sendto.fd = sockfd;
@@ -1975,7 +2148,7 @@ static __yo_io_future_t* __yo_async_recvfrom_start(int32_t sockfd, void* buf, si
   atomic_init(&future->state, 0);
   future->result = 0;
   
-  __yo_io_pending_op_t* pending = (__yo_io_pending_op_t*)__yo_malloc(sizeof(__yo_io_pending_op_t));
+  __yo_io_pending_op_t* pending = __yo_kq_alloc_pending();
   pending->op = __YO_IO_OP_RECVFROM;
   pending->future = future;
   pending->recvfrom.fd = sockfd;
@@ -2560,6 +2733,13 @@ static uint64_t __yo_statx_blocks(void* statxbuf) {
 static _Thread_local struct io_uring __yo_io_ring;
 // __yo_io_initialized is defined in runtime-core
 static _Thread_local size_t __yo_pending_io_count = 0;
+// Ring size matches the fixed io_uring queue depth we initialize below.
+#define __YO_IO_RING_ENTRIES 1024
+// Number of SQEs queued in userspace but not yet submitted to the kernel.
+// Deferred submission lets us batch many SQEs into a single syscall.
+static _Thread_local unsigned __yo_sq_unsubmitted = 0;
+static _Thread_local unsigned __yo_sq_deferred_head = 0;
+static _Thread_local __yo_io_future_t* __yo_sq_deferred_futures[__YO_IO_RING_ENTRIES];
 
 // I/O Future types - __yo_io_future_t is defined in types/generation.ts
 // It has the same layout as async state machines (state, result, continuation_fn, continuation_sm)
@@ -2569,19 +2749,54 @@ static _Thread_local size_t __yo_pending_io_count = 0;
 // Initialize io_uring (called once at event loop start)
 static void __yo_io_init(void) {
   if (__yo_io_initialized) return;
-  
-  int ret = io_uring_queue_init(256, &__yo_io_ring, 0);
+
+  // Try modern kernel flags for lower overhead (requires Linux 6.0+):
+  //   IORING_SETUP_COOP_TASKRUN \u2014 avoids inter-processor interrupts on task wakeup
+  //     since we know our thread will reap completions.
+  //   IORING_SETUP_SINGLE_ISSUER \u2014 we only submit from the owner thread.
+  //   IORING_SETUP_DEFER_TASKRUN \u2014 completions run only when we call wait_cqe,
+  //     avoiding random overhead on timer interrupts.
+  struct io_uring_params params;
+  memset(&params, 0, sizeof(params));
+#ifdef IORING_SETUP_SINGLE_ISSUER
+  params.flags |= IORING_SETUP_SINGLE_ISSUER;
+#endif
+#ifdef IORING_SETUP_COOP_TASKRUN
+  params.flags |= IORING_SETUP_COOP_TASKRUN;
+#endif
+#ifdef IORING_SETUP_DEFER_TASKRUN
+  params.flags |= IORING_SETUP_DEFER_TASKRUN;
+#endif
+
+  int ret = io_uring_queue_init_params(__YO_IO_RING_ENTRIES, &__yo_io_ring, &params);
+  if (ret < 0) {
+    // Retry without any flags for older kernels
+    memset(&params, 0, sizeof(params));
+    ret = io_uring_queue_init_params(__YO_IO_RING_ENTRIES, &__yo_io_ring, &params);
+  }
   if (ret < 0) {
     fprintf(stderr, "[Yo] io_uring_queue_init failed: %s\\n", strerror(-ret));
     exit(1);
   }
   __yo_io_initialized = true;
-  ASYNC_DEBUG("[IO] io_uring initialized with 256 entries\\n");
+  ASYNC_DEBUG("[IO] io_uring initialized with %d entries (flags=0x%x)\\n", __YO_IO_RING_ENTRIES, params.flags);
 }
 
 // Cleanup io_uring
 static void __yo_io_cleanup(void) {
   if (!__yo_io_initialized) return;
+  // If async main returns while some SQEs are still only queued in userspace,
+  // cancel them here instead of silently dropping the event-loop ref we took in
+  // __yo_io_ring_submit.
+  while (__yo_sq_unsubmitted > 0) {
+    __yo_io_future_t* future = __yo_sq_deferred_futures[__yo_sq_deferred_head];
+    __yo_sq_deferred_head = (__yo_sq_deferred_head + 1) % __YO_IO_RING_ENTRIES;
+    __yo_sq_unsubmitted--;
+    __yo_pending_io_count--;
+    future->result = -ECANCELED;
+    future->state = -1;
+    __yo_decr_rc((void*)future);
+  }
   io_uring_queue_exit(&__yo_io_ring);
   __yo_io_initialized = false;
   ASYNC_DEBUG("[IO] io_uring cleaned up\\n");
@@ -2595,13 +2810,35 @@ static inline bool __yo_has_pending_io(void) {
 // Forward declaration for poll/fs_event tick (defined in runtime-io-common)
 static int __yo_poll_and_fs_event_tick(void);
 
-// Submit an SQE to io_uring with an event-loop RC reference.
-// The reference is released in __yo_io_process_cqe after the CQE is consumed,
-// preventing use-after-free if the user drops the future before completion.
+// Queue an SQE for later submission to io_uring (deferred submit).
+// The actual io_uring_submit() syscall happens inside __yo_io_poll / __yo_io_wait,
+// so many SQEs produced within one "drain tasks" pass batch into one syscall.
 static inline void __yo_io_ring_submit(__yo_io_future_t* future) {
   future->header.ref_count++;    // io_uring holds a reference until CQE
-  io_uring_submit(&__yo_io_ring);
   __yo_pending_io_count++;
+  __yo_sq_deferred_futures[(__yo_sq_deferred_head + __yo_sq_unsubmitted) % __YO_IO_RING_ENTRIES] = future;
+  __yo_sq_unsubmitted++;
+}
+
+// Flush any queued SQEs to the kernel if non-empty. Returns the liburing result.
+// On failure (ret < 0), the SQEs remain in the SQ ring so __yo_sq_unsubmitted
+// is left unchanged -- the next submit attempt (via poll/wait) will retry them.
+static inline int __yo_io_flush_sq(void) {
+  if (__yo_sq_unsubmitted == 0) return 0;
+  int ret;
+  do {
+    ret = io_uring_submit(&__yo_io_ring);
+  } while (ret == -EINTR);
+  if (ret > 0) {
+    if ((size_t)ret >= __yo_sq_unsubmitted) {
+      __yo_sq_deferred_head = (__yo_sq_deferred_head + __yo_sq_unsubmitted) % __YO_IO_RING_ENTRIES;
+      __yo_sq_unsubmitted = 0;
+    } else {
+      __yo_sq_deferred_head = (__yo_sq_deferred_head + (unsigned)ret) % __YO_IO_RING_ENTRIES;
+      __yo_sq_unsubmitted -= (size_t)ret;
+    }
+  }
+  return ret;
 }
 
 // Process completions from CQ
@@ -2640,17 +2877,24 @@ static void __yo_io_process_cqe(struct io_uring_cqe* cqe) {
 
 // Poll for I/O completions (non-blocking)
 static int __yo_io_poll(void) {
-  struct io_uring_cqe* cqe;
+  // Flush any queued SQEs so their completions can be reaped.
+  __yo_io_flush_sq();
+
+  struct io_uring_cqe* cqes[64];
   int count = 0;
-  
-  while (io_uring_peek_cqe(&__yo_io_ring, &cqe) == 0) {
-    __yo_io_process_cqe(cqe);
-    count++;
+
+  unsigned n;
+  while ((n = io_uring_peek_batch_cqe(&__yo_io_ring, cqes, 64)) > 0) {
+    for (unsigned i = 0; i < n; ++i) {
+      __yo_io_process_cqe(cqes[i]);
+      count++;
+    }
+    if (n < 64) break;
   }
-  
+
   // Also tick poll/fs_event handles
   count += __yo_poll_and_fs_event_tick();
-  
+
   if (count > 0) {
     ASYNC_DEBUG("[IO] Polled %d completions\\n", count);
   }
@@ -2665,14 +2909,42 @@ static int __yo_io_wait(void) {
     nanosleep(&ts, NULL);
     return __yo_poll_and_fs_event_tick();
   }
-  
+
   struct io_uring_cqe* cqe;
-  int ret = io_uring_wait_cqe(&__yo_io_ring, &cqe);
-  if (ret < 0) {
-    ASYNC_DEBUG("[IO] WARNING: io_uring_wait_cqe failed: %d\\n", ret);
-    return 0;
+  // Combined submit + wait in a single syscall -- this is the main batching win:
+  // all deferred SQEs are submitted alongside the blocking wait for a CQE.
+  int ret;
+  if (__yo_sq_unsubmitted > 0) {
+    do {
+      ret = io_uring_submit_and_wait(&__yo_io_ring, 1);
+    } while (ret == -EINTR);
+    if (ret < 0) {
+      // SQEs remain in the SQ ring; do not drop __yo_sq_unsubmitted so the
+      // next poll/wait retries them.
+      ASYNC_DEBUG("[IO] WARNING: io_uring_submit_and_wait failed: %d\\n", ret);
+      return 0;
+    }
+    // ret >= 0: that many SQEs were submitted.
+    if ((size_t)ret >= __yo_sq_unsubmitted) {
+      __yo_sq_deferred_head = (__yo_sq_deferred_head + __yo_sq_unsubmitted) % __YO_IO_RING_ENTRIES;
+      __yo_sq_unsubmitted = 0;
+    } else {
+      __yo_sq_deferred_head = (__yo_sq_deferred_head + (unsigned)ret) % __YO_IO_RING_ENTRIES;
+      __yo_sq_unsubmitted -= (size_t)ret;
+    }
+    // After submit_and_wait, at least one CQE should be available; peek it.
+    if (io_uring_peek_cqe(&__yo_io_ring, &cqe) != 0) {
+      // Rare: spurious wake. Fall back to explicit wait.
+      if (io_uring_wait_cqe(&__yo_io_ring, &cqe) < 0) return 0;
+    }
+  } else {
+    ret = io_uring_wait_cqe(&__yo_io_ring, &cqe);
+    if (ret < 0) {
+      ASYNC_DEBUG("[IO] WARNING: io_uring_wait_cqe failed: %d\\n", ret);
+      return 0;
+    }
   }
-  
+
   ASYNC_DEBUG("[IO] Waiting for I/O completion...\\n");
   __yo_io_process_cqe(cqe);
   return 1 + __yo_io_poll();  // Process any additional completions
@@ -5509,6 +5781,12 @@ typedef struct {
   DWORD sock_flags;
 } __yo_win_overlapped_t;
 
+// Per-thread free list for __yo_win_overlapped_t to eliminate malloc/free
+// per I/O op. The first sizeof(void*) bytes of an overlapped struct overlay
+// the 'next' pointer when the struct is on the free list (it is fully
+// re-initialized on alloc, so trampling OVERLAPPED.Internal is fine).
+static __declspec(thread) __yo_win_overlapped_t* __yo_win_ov_free_list = NULL;
+
 
 static void __yo_io_init(void) {
   if (__yo_io_initialized) return;
@@ -5632,10 +5910,27 @@ static DWORD __yo_win_timer_next_timeout(uint64_t now_ms) {
   return (DWORD)delta;
 }
 
+// Forward declarations -- these are defined after the IOCP poll/wait
+// functions but called by __yo_win_process_completion which comes first.
+static __yo_win_overlapped_t* __yo_win_alloc_overlapped(__yo_io_future_t* future, HANDLE handle, uint64_t offset);
+static inline void __yo_win_free_overlapped(__yo_win_overlapped_t* ov);
+
 static void __yo_win_process_completion(__yo_win_overlapped_t* ov, DWORD bytes) {
   if (!ov) return;
 
-  if (ov->is_socket) {
+  // The byte count is already in OVERLAPPED_ENTRY.dwNumberOfBytesTransferred
+  // (passed in as the bytes argument) and the NTSTATUS is in
+  // ov->overlapped.Internal. Calling WSAGetOverlappedResult /
+  // GetOverlappedResult here would do redundant work -- those APIs
+  // essentially return what IOCP already gave us. Use the OVERLAPPED
+  // fields directly to save a per-completion syscall.
+  NTSTATUS status = (NTSTATUS)ov->overlapped.Internal;
+  if (status == 0) {
+    ov->future->result = (int32_t)bytes;
+  } else if (ov->is_socket) {
+    // RtlNtStatusToDosError lives in ntdll; rather than dynamically loading
+    // it, fall back to the same WSAGetOverlappedResult path on error so
+    // we get the proper WSA errno mapping.
     DWORD flags = 0;
     DWORD transferred = bytes;
     BOOL ok = WSAGetOverlappedResult(ov->sock, &ov->overlapped, &transferred, FALSE, &flags);
@@ -5660,7 +5955,7 @@ static void __yo_win_process_completion(__yo_win_overlapped_t* ov, DWORD bytes)
   }
 
   __yo_io_wake_continuation(ov->future);
-  __yo_free(ov);
+  __yo_win_free_overlapped(ov);
 }
 
 static int __yo_io_poll(void) {
@@ -5696,24 +5991,32 @@ static int __yo_io_wait(void) {
   }
   if (__yo_pending_io_count == 0) return 0;
 
-  DWORD bytes = 0;
-  ULONG_PTR key = 0;
-  OVERLAPPED* ov = NULL;
   DWORD timeout_ms = __yo_win_timer_next_timeout(__yo_win_now_ms());
   if (__yo_active_watch_count > 0 && (timeout_ms == INFINITE || timeout_ms > 50)) {
     timeout_ms = 50;
   }
-  BOOL ok = GetQueuedCompletionStatus(__yo_io_iocp, &bytes, &key, &ov, timeout_ms);
-  if (!ok && GetLastError() == WAIT_TIMEOUT) {
-    return __yo_win_timer_process_due(__yo_win_now_ms()) + __yo_poll_and_fs_event_tick();
-  }
+
+  // Use the batched Ex variant so that when the wait wakes up due to one
+  // ready completion we drain ALL ready completions in a single syscall,
+  // rather than taking N trips through the event loop for N completions
+  // ready at the same time. This is the Windows analogue of Linux's
+  // io_uring_submit_and_wait + peek_batch_cqe pattern and matters a lot
+  // for HTTP-style workloads where many sockets become ready together.
+  OVERLAPPED_ENTRY entries[64];
+  ULONG count = 0;
+  BOOL ok = GetQueuedCompletionStatusEx(__yo_io_iocp, entries, 64, &count, timeout_ms, FALSE);
   if (!ok) {
     return __yo_win_timer_process_due(__yo_win_now_ms()) + __yo_poll_and_fs_event_tick();
   }
-  if (!ov) return __yo_poll_and_fs_event_tick();
 
-  __yo_win_process_completion((__yo_win_overlapped_t*)ov, bytes);
-  return 1 + __yo_win_timer_process_due(__yo_win_now_ms()) + __yo_poll_and_fs_event_tick();
+  int processed = 0;
+  for (ULONG i = 0; i < count; i++) {
+    if (!entries[i].lpOverlapped) continue;
+    __yo_win_process_completion((__yo_win_overlapped_t*)entries[i].lpOverlapped,
+                                entries[i].dwNumberOfBytesTransferred);
+    processed++;
+  }
+  return processed + __yo_win_timer_process_due(__yo_win_now_ms()) + __yo_poll_and_fs_event_tick();
 }
 
 
@@ -5753,8 +6056,14 @@ static void __yo_win_fd_unmark_append(int fd) {
 static void __yo_win_cleanup_dir_state(int32_t fd);
 
 static __yo_win_overlapped_t* __yo_win_alloc_overlapped(__yo_io_future_t* future, HANDLE handle, uint64_t offset) {
-  __yo_win_overlapped_t* ov = (__yo_win_overlapped_t*)__yo_malloc(sizeof(__yo_win_overlapped_t));
-  if (!ov) return NULL;
+  __yo_win_overlapped_t* ov;
+  if (__yo_win_ov_free_list) {
+    ov = __yo_win_ov_free_list;
+    __yo_win_ov_free_list = *(__yo_win_overlapped_t**)ov;
+  } else {
+    ov = (__yo_win_overlapped_t*)__yo_malloc(sizeof(__yo_win_overlapped_t));
+    if (!ov) return NULL;
+  }
   memset(ov, 0, sizeof(__yo_win_overlapped_t));
   ov->future = future;
   ov->handle = handle;
@@ -5765,6 +6074,18 @@ static __yo_win_overlapped_t* __yo_win_alloc_overlapped(__yo_io_future_t* future
   return ov;
 }
 
+// Return an overlapped struct to the per-thread free list. Used by the
+// IOCP completion path AND by the synchronous-completion paths in
+// recv/send (where FILE_SKIP_COMPLETION_PORT_ON_SUCCESS means no IOCP
+// packet will arrive) and by error paths. The first sizeof(void*) bytes
+// of the struct are repurposed for the free-list pointer; alloc re-zeroes
+// the entire struct so this is safe.
+static inline void __yo_win_free_overlapped(__yo_win_overlapped_t* ov) {
+  if (!ov) return;
+  *(__yo_win_overlapped_t**)ov = __yo_win_ov_free_list;
+  __yo_win_ov_free_list = ov;
+}
+
 static DWORD __yo_win_access_flags(int32_t flags) {
   if ((flags & O_RDWR) == O_RDWR) return GENERIC_READ | GENERIC_WRITE;
   if (flags & O_WRONLY) return GENERIC_WRITE;
@@ -5827,13 +6148,13 @@ static __yo_io_future_t* __yo_async_read_start(int32_t fd, void* buffer, uint32_
     DWORD bytes_transferred = 0;
     GetOverlappedResult(handle, &ov->overlapped, &bytes_transferred, FALSE);
     future->result = (int32_t)bytes_transferred;
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     atomic_store(&future->state, -1);
     return future;
   }
   DWORD err = GetLastError();
   if (err != ERROR_IO_PENDING) {
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     if (err == ERROR_HANDLE_EOF) {
       future->result = 0;
     } else {
@@ -5902,13 +6223,13 @@ static __yo_io_future_t* __yo_async_write_start(int32_t fd, const void* buffer,
     DWORD bytes_transferred = 0;
     GetOverlappedResult(handle, &ov->overlapped, &bytes_transferred, FALSE);
     future->result = (int32_t)bytes_transferred;
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     atomic_store(&future->state, -1);
     return future;
   }
   DWORD err = GetLastError();
   if (err != ERROR_IO_PENDING) {
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     future->result = -__yo_win_error_to_errno(err);
     atomic_store(&future->state, -1);
     return future;
@@ -6627,7 +6948,7 @@ static __yo_io_future_t* __yo_async_send_start(int32_t sockfd, const void* buf,
     // no IOCP packet will be posted, so complete the future immediately.
     future->result = (int32_t)sent;
     atomic_init(&future->state, -1);
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     return future;
   }
   if (result == SOCKET_ERROR && WSAGetLastError() == WSA_IO_PENDING) {
@@ -6638,7 +6959,7 @@ static __yo_io_future_t* __yo_async_send_start(int32_t sockfd, const void* buf,
 
   future->result = -(int32_t)WSAGetLastError();
   atomic_init(&future->state, -1);
-  __yo_free(ov);
+  __yo_win_free_overlapped(ov);
   return future;
 }
 
@@ -6676,7 +6997,7 @@ static __yo_io_future_t* __yo_async_recv_start(int32_t sockfd, void* buf, size_t
     // no IOCP packet will be posted, so complete the future immediately.
     future->result = (int32_t)received;
     atomic_init(&future->state, -1);
-    __yo_free(ov);
+    __yo_win_free_overlapped(ov);
     return future;
   }
   if (result == SOCKET_ERROR && WSAGetLastError() == WSA_IO_PENDING) {
@@ -6687,7 +7008,7 @@ static __yo_io_future_t* __yo_async_recv_start(int32_t sockfd, void* buf, size_t
 
   future->result = -(int32_t)WSAGetLastError();
   atomic_init(&future->state, -1);
-  __yo_free(ov);
+  __yo_win_free_overlapped(ov);
   return future;
 }