@case-framework/survey-assistant 0.7.0 → 0.9.0

package/dist/lifecycle-DFzxVxpq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-DFzxVxpq.d.mts","names":[],"sources":["../src/protocol/document.ts","../src/protocol/operations.ts","../src/protocol/lifecycle.ts"],"mappings":";;;;;UAgBU;EACR;EACA;EACA;EACA;EACA;;;UAIe;;EAEf;;EAEA;;EAEA;;EAEA,OAAO;;UAGC;EACR;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa;IACX;IACA;IACA;IACA;IACA;;EAEF,OAAO;EACP;IACE;IACA;IACA;IACA;IACA,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;;;;UAKI;EACR;EACA,SAAS;EACT,QAAQ;;EAER,cAAc;EACd,IAAI;EACJ,cAAc;EACd;;cAGW;cACA,sCAAoC,EAAA;cAEpC,6BAA6B,EAAE,QAAQ;cAQvC;cAEA,0BAA0B,EAAE,QAAQ;cAWpC,6BAA6B,EAAE,QAAQ;cAoDvC,yBAAyB,EAAE,QAAQ;cAInC,8BAA8B,EAAE,QAAQ;cAUxC,+BAA6B,EAAA,QAAA,sCAAA,EAAA,KAAA,kBAAA;cAC7B,sCAAoC,EAAA,QAAA,sCAAA,EAAA,KAAA,kBAAA;KAErC,iCAAiC,EAAE,aAAa;KAChD,wBAAwB,EAAE,aAAa;KACvC,wBAAwB,EAAE,aAAa;KACvC,qBAAqB,EAAE,aAAa;KACpC,oBAAoB,EAAE,aAAa;KACnC,yBAAyB,EAAE,aAAa;KAIxC,0BAA0B;KAC1B,iCAAiC;KAGjC,0CAA0C;KAC1C,sCAAsC;KACtC,yCAAyC;cACxC,8CAA4C,EAAA,QAAA,qCAAA,EAAA,KAAA,kBAAA;;;cC/H5C,uBAAqB,EAAA,uBAAA,EAAA;;;;;;;;;;;;GAWhC,EAAA,KAAA;cAqBW,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEU,EAAA,KAAA;cAahC,0BAA0B,EAAE,QAAQ;cAkBpC,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQpC,EAAA,KAAA;cACW,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQvC,EAAA,KAAA;cACW,6BAA2B,EAAA;;;;;;;;;;;;;GAWtC,EAAA,KAAA;cACW,6BAA2B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWtC,EAAA,KAAA;cACW,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAOI,EAAA,KAAA;cAChC,mCAAiC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM5C,EAAA,KAAA;cACW,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMzC,EAAA,KAAA;cACW,gCAA8B,EAAA;;;;;GAUzC,EAAA,KAAA;cACW,gCAA8B,EAAA;;;;;;;;;;;;;;;;;GASzC,EAAA,KAAA;cACW,2BAAyB,EAAA;;;;;GAUpC,EAAA,KAAA;cACW,yBAAuB,EAAA;;;;;;;;GAKlC,EAAA,KAAA;cACW,6BAA2B,EAAA;;;;;GAQtC,EAAA,KAAA;cACW,4BAA0B,EAAA;;;;;;;;;;;;GAMrC,EAAA,KAAA;cACW,0BAAwB,EAAA;;;;;;;;;;GASnC,EAAA,KAAA;cACW,8BAA4B,EAAA;;;;GAMvC,EAAA,KAAA;cACW,6BAA2B,EAAA;;;;;;;;;;;;;;;;;GAOtC,EAAA,KAAA;cAEW,kCAAgC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgC3C,EAAA,KAAA;cACW,qCAAmC,EAAA;;;;GAM9C,EAAA,KAAA;cACW,uCAAqC,EAAA;;;;;;;GAMhD,EAAA,KAAA;cACW,wCAAsC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQN,EAAA,KAAA;cAChC,gCAA8B,EAAA;;;;GAIzC,EAAA,KAAA;cACW,mCAAiC,EAAA;;;;GAI5C,EAAA,KAAA;cAQW,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;GAcvC,EAAA,KAAA;cACW,yCAAuC,EAAA;;;;;;;;;;;GAWlD,EAAA,KAAA;cACW,iCAA+B,EAAA;;;;GAI1C,EAAA,KAAA;cACW,4BAA0B,EAAA;;;;GAIrC,EAAA,KAAA;cACW,uCAAqC,EAAA;;;;;GAEvC,EAAA,KAAA;UACD;EACR,sBAAsB;EACtB,yBAAyB;EACzB,wBAAwB;EACxB,wBAAwB;EACxB,yBAAyB;EACzB,+BAA+B;EAC/B,4BAA4B;EAC5B,4BAA4B;EAC5B,4BAA4B;EAC5B,sBAAsB;EACtB,oBAAoB;EACpB,wBAAwB;EACxB,uBAAuB;EACvB,qBAAqB;EACrB,yBAAyB;EACzB,wBAAwB;EACxB,8BAA8B;EAC9B,iCAAiC;EACjC,mCAAmC;EACnC,oCAAoC;EACpC,4BAA4B;EAC5B,+BAA+B;EAC/B,0BAA0B;EAC1B,sCAAsC;EACtC,6BAA6B;EAC7B,4BAA4B;EAC5B,mCAAmC;;cAExB,8BAA8B;KA6B/B,kBAAkB,EAAE,MAAM,6BAA6B;cACtD,uBAAuB,EAAE,QAAQ;KAOlC,sBAAsB;cACrB,kCAEE,wBAAwB;cAC1B,6BAA2B,EAAA;;;;;;;;;;GAOtC,EAAA,KAAA;cACW,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAKvC,EAAA,KAAA;KACU,wBAAwB,EAAE,aAAa;KACvC,yBAAyB,EAAE,aAAa;KACxC,uBAAqB,EAAE,aAAa;;;UCrc/B;EACf;EACA;EACA;EACA;EACA;EACA,YAAY;EACZ;EACA,iBAAiB;IACf;IACA;IACA;IACA;;EAEF,eAAe;EACf,aAAa;EACb,eAAe;EACf,YAAY;EACZ;;cAGI;UAOI;EACR;EACA,SAAS,cAAc;EACvB;EACA,eAAe;IACb;IACA;IACA;IAQA;IACA;IACA,mBAAmB;IACnB;IACA;IACA;;EAEF;;UAGQ;EACR,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA;EACA,cAAc;IACZ;IACA;IACA;IACA;IACA;IACA;MACE;MACA;MACA;MACA;MACA;MACA;;IAEF;MAAe;MAAmB;MAAe;MAAoB;;IACrE;IACA,cAAc;MACZ;MACA;MACA;MACA;MACA;MACA;;IAEF;IACA;IACA;;EAEF;;cAGI;UAaI;EACR;EACA;EACA;EACA;EACA;EACA;EACA;EACA,4BAA4B;EAC5B;;KAGG;cAEQ;cACA;KAGR;UAEK;EACR,QAAQ;EACR;EACA;EACA;EACA;EACA,SAAS;;UAGD;EACR,SAAS;;UAGD;EACR,QAAQ;EACR;EACA;EACA;EACA;;UAGQ;EACR;EACA;EACA;EACA;;cAGI;UAMI;EACR;EACA;EACA,gBAAgB;EAChB;EACA,UAAU;EACV,kBAAkB;EAClB;;UAGQ;EACR;EACA;EACA;EACA,eAAe;EACf,eAAe;EACf,QAAQ;EACR;EACA;IAAW;IAAa;;EACxB,SAAS;EACT;;cAGW,uBAAuB,EAAE,QAAQ;cAmHjC,4CAA0C,EAAA;;;;;;;;;;;;cAI1C,gCAAgC,EAAE,QAAQ;cAuD1C,kCAAkC,EAAE,QAAQ;cAM5C,yBAAyB,EAAE,QAAQ;cAOnC,yBAAyB,EAAE,QAAQ;cASnC,8BAA8B,EAAE,QAAQ;cAIxC,mCAAmC,EAAE,QAAQ;cAgC7C,oBAAoB,EAAE,QAAQ;KAkB/B,kBAAkB,EAAE,aAAa;KACjC,2BAA2B,EAAE,aAAa;KAC1C,uCAAuC,EAAE,aAC5C;KAEG,6BAA6B,EAAE,aAAa;KAC5C,oBAAoB,EAAE,aAAa;KACnC,oBAAoB,EAAE,aAAa;KACnC,yBAAyB,EAAE,aAAa;KACxC,8BAA8B,EAAE,aAAa;KAC7C,eAAe,EAAE,aAAa;cAI7B,uCAAqC,EAAA,QAAA,+BAAA,EAAA,KAAA,kBAAA;KACtC,kCAAkC;KAClC,6BAA6B;KAC7B,6BAA6B;KAC7B,kCAAkC"}

package/dist/{memory-thread-repository-KWHQWFEW.mjs → memory-thread-repository-DmLadygY.mjs}

@@ -1,13 +1,24 @@
-import { A as createSurveyAssistantThreadInputSchema, Bt as sanitizeSurveyAssistantDiagnosticText, Nt as serializeSurveyAssistantError, P as updateSurveyAssistantThreadInputSchema, jt as isSurveyAssistantErrorRetryable, k as SURVEY_ASSISTANT_ATTACHMENT_PART_TYPE, n as SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE } from "./protocol-BhzQbx81.mjs";
-import { t as SurveyAssistantCapabilityMismatchError } from "./capabilities-1KNnNO1_.mjs";
-import { l as TurnSurveyDraft } from "./engine-Bo85Oyj0.mjs";
-import "./constants-0UHGFcRJ.mjs";
-import { a as parseSurveyAssistantPreviousSettledVersion, i as parseSurveyAssistantPreviousApplyOutcome, o as parseSurveyAssistantSnapshot, t as buildSurveyAssistantRequestContext } from "./request-context-CG4SWijt.mjs";
-import { d as readSurveyAssistantRequestJson, f as validateSurveyAssistantMessages, n as SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS, u as SurveyAssistantRequestError } from "./request-guardrails-TmgQtqp4.mjs";
+import { I as updateSurveyAssistantThreadInputSchema, J as isSurveyAssistantErrorRetryable, M as createSurveyAssistantThreadInputSchema, X as serializeSurveyAssistantError, j as SURVEY_ASSISTANT_ATTACHMENT_PART_TYPE, n as SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE, q as surveyEditorUITaskSchema, rt as sanitizeSurveyAssistantDiagnosticText } from "./protocol-BQ7uIDYT.mjs";
+import { r as TurnSurveyDraft } from "./engine-D950TfvC.mjs";
+import { i as SurveyAssistantCapabilityMismatchError } from "./default-D22AKTqE.mjs";
+import "./constants-Ct-vv9cu.mjs";
+import { a as parseSurveyAssistantPreviousSettledVersion, i as parseSurveyAssistantPreviousApplyOutcome, o as parseSurveyAssistantSnapshot, t as buildSurveyAssistantRequestContext } from "./request-context-KVh8VjgH.mjs";
+import { d as readSurveyAssistantRequestJson, f as validateSurveyAssistantMessages, n as SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS, u as SurveyAssistantRequestError } from "./request-guardrails-C0ugBOp0.mjs";
 import { createUIMessageStreamResponse } from "ai";
-import { handleChatStream } from "@mastra/ai-sdk";
 import { createHash } from "node:crypto";
+import { handleChatStream } from "@mastra/ai-sdk";
 import { toAISdkMessages } from "@mastra/ai-sdk/ui";
+//#region src/server/message-identity.ts
+/** Bind client message ids to the host-authorized storage scope before Mastra's id-only upsert. */
+const scopeSurveyAssistantMessage = (message, identity) => {
+	const prefix = `survey-user-${createHash("sha256").update(JSON.stringify([identity.resourceId, identity.threadId])).digest("hex")}-`;
+	return {
+		id: message.id.startsWith(prefix) && /^[a-f0-9]{64}$/.test(message.id.slice(prefix.length)) ? message.id : `${prefix}${createHash("sha256").update(message.id).digest("hex")}`,
+		role: "user",
+		parts: message.parts
+	};
+};
+//#endregion
 //#region src/server/execution-timeout.ts
 const timeoutMessages = {
 	"first-response": "The survey assistant timed out while waiting for its first response.",
@@ -146,8 +157,10 @@ const createSurveyAssistantTurnStream = ({ turnDraft, getAbortErrorText, getAbor
 					}
 					controller.enqueue(value);
 				}
-				if (!emittedTurnFinal) if (signal?.aborted) emitAbortOutcome();
-				else emitTurnFinal(sawFinish && (finishReason === void 0 || finishReason === "stop") ? "completed" : "failed", sawFinish && finishReason !== void 0 && finishReason !== "stop" ? getFinishTerminationReason(finishReason) : !sawFinish ? "incomplete-response" : void 0);
+				if (!emittedTurnFinal) {
+					if (signal?.aborted) emitAbortOutcome();
+					else emitTurnFinal(sawFinish && (finishReason === void 0 || finishReason === "stop") ? "completed" : "failed", sawFinish && finishReason !== void 0 && finishReason !== "stop" ? getFinishTerminationReason(finishReason) : !sawFinish ? "incomplete-response" : void 0);
+				}
 				controller.close();
 			} catch (error) {
 				try {
@@ -219,8 +232,9 @@ const replaceCurrentSurveyAssistantAttachmentsWithReferences = ({ documents, mes
 			changed = true;
 			const parsed = typeof part.url === "string" ? parseFileDataUrl(part.url) : null;
 			const mediaType = parsed?.mediaType || part.mediaType;
+			const document = parsed ? documentIndex.get(`${mediaType}\u0000${getAttachmentContentHash(parsed.data)}`) : void 0;
 			return createAttachmentReferencePart({
-				document: parsed ? documentIndex.get(`${mediaType}\u0000${getAttachmentContentHash(parsed.data)}`) : void 0,
+				document,
 				filename: part.filename,
 				mediaType,
 				parsedData: parsed?.data
@@ -273,8 +287,9 @@ const removeHistoricalSurveyAssistantAttachments = (messages) => {
 */
 const getSurveyAssistantReplayableDocuments = (documents, currentDocumentIds) => documents.filter((document) => !currentDocumentIds.has(document.id));
 const loadSurveyAssistantThreadAttachments = async ({ currentDocumentIds = /* @__PURE__ */ new Set(), documents, repository, resourceId, threadId }) => {
+	const replayableDocuments = getSurveyAssistantReplayableDocuments(documents, currentDocumentIds);
 	return loadSurveyAssistantDocuments({
-		documents: getSurveyAssistantReplayableDocuments(documents, currentDocumentIds),
+		documents: replayableDocuments,
 		repository,
 		resourceId,
 		threadId
@@ -290,6 +305,7 @@ const loadSurveyAssistantDocuments = async ({ documents, repository, resourceId,
 		});
 		if (!content) continue;
 		attachments.push({
+			documentId: document.id,
 			filename: content.name,
 			mediaType: content.mediaType,
 			data: content.data,
@@ -302,9 +318,9 @@ const loadSurveyAssistantDocuments = async ({ documents, repository, resourceId,
 //#region src/server/handler.ts
 const DEFAULT_MAX_STEPS = 48;
 const DEFAULT_MAX_CONCURRENT_REQUESTS = 8;
-const DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 900 * 1e3;
-const DEFAULT_IDLE_TIMEOUT_MS = 300 * 1e3;
-const DEFAULT_MAX_DURATION_MS = 3600 * 1e3;
+const DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 9e5;
+const DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+const DEFAULT_MAX_DURATION_MS = 36e5;
 const MAX_ERROR_CAUSE_DEPTH = 5;
 const getTimeoutTerminationReason = (kind) => {
 	switch (kind) {
@@ -560,7 +576,7 @@ const createSurveyAssistantChatHandler = (options) => {
 		}
 		let messages;
 		try {
-			messages = validateSurveyAssistantMessages(params.messages, requestLimits);
+			messages = validateSurveyAssistantMessages(params.messages, requestLimits).map((message) => scopeSurveyAssistantMessage(message, identity));
 		} catch (error) {
 			return requestErrorResponse(error, "The survey assistant messages are invalid.");
 		}
@@ -645,12 +661,14 @@ const createSurveyAssistantChatHandler = (options) => {
 					messages
 				});
 				messages = removeHistoricalSurveyAssistantAttachments(messages);
-				const replayableDocuments = getSurveyAssistantReplayableDocuments(manifest, new Set(registered.map((document) => document.id)));
+				const registeredIds = new Set(registered.map((document) => document.id));
+				const replayableDocuments = getSurveyAssistantReplayableDocuments(manifest, registeredIds);
 				const documents = [...registered, ...replayableDocuments];
 				if (documents.length > 0) attachmentAccess = {
 					documents,
 					currentDocumentIds: registered.map((document) => document.id),
 					selectedAttachments: [],
+					limits: requestLimits,
 					load: (documentIds) => loadSurveyAssistantDocuments({
 						documents: documents.filter((document) => documentIds.includes(document.id)),
 						repository,
@@ -720,8 +738,9 @@ const createSurveyAssistantChatHandler = (options) => {
 		};
 		let stream;
 		try {
+			const mastra = typeof options.mastra === "function" ? await options.mastra() : options.mastra;
 			stream = await handleChatStream({
-				mastra: typeof options.mastra === "function" ? await options.mastra() : options.mastra,
+				mastra,
 				agentId: options.agentId ?? "survey-assistant-agent",
 				version: "v6",
 				params: {
@@ -761,7 +780,7 @@ const createSurveyAssistantChatHandler = (options) => {
 			releaseRequestSlot();
 			return Response.json({ error: executionTimeout.timeoutKind ? getSurveyAssistantExecutionTimeoutMessage(executionTimeout.timeoutKind) : handleStreamError(error) }, { status: 503 });
 		}
-		return createUIMessageStreamResponse({ stream: createSurveyAssistantTurnStream({
+		const turnStream = createSurveyAssistantTurnStream({
 			stream,
 			turnDraft,
 			signal: executionSignal,
@@ -789,13 +808,16 @@ const createSurveyAssistantChatHandler = (options) => {
 				}
 			},
 			turnStartedAt: executionStartedAt
-		}) });
+		});
+		return createUIMessageStreamResponse({ stream: turnStream });
 	};
 };
 //#endregion
 //#region src/server/thread-handlers.ts
 const DEFAULT_TITLE = "New chat";
-const MAX_THREAD_MUTATION_BYTES = 16 * 1024;
+const MAX_THREAD_MUTATION_BYTES = 16384;
+const MAX_THREAD_CREATE_BYTES = 262144;
+const TASK_METADATA_KEY = "surveyAssistant.task";
 const MANUAL_TITLE_METADATA_KEY = "surveyAssistant.manualTitle";
 const AUTOMATIC_TITLE_METADATA_KEY = "surveyAssistant.automaticTitle";
 const getMetadataString = (metadata, key) => {
@@ -808,14 +830,17 @@ const getAutomaticTitle = (thread, manualTitle) => {
 	if (rawTitle && rawTitle !== manualTitle) return rawTitle;
 	return getMetadataString(thread.metadata, AUTOMATIC_TITLE_METADATA_KEY) ?? DEFAULT_TITLE;
 };
-const asThread = (thread) => {
+const asThread = (thread, includeTask = true) => {
 	const manualTitle = getMetadataString(thread.metadata, MANUAL_TITLE_METADATA_KEY);
+	const parsedTask = includeTask ? surveyEditorUITaskSchema.safeParse(thread.metadata?.[TASK_METADATA_KEY]) : void 0;
+	const task = parsedTask?.success ? parsedTask.data : void 0;
 	return {
 		id: thread.id,
 		title: manualTitle ?? getRawTitle(thread),
 		titleMode: manualTitle ? "manual" : "automatic",
 		createdAt: thread.createdAt.toISOString(),
-		updatedAt: thread.updatedAt.toISOString()
+		updatedAt: thread.updatedAt.toISOString(),
+		...task ? { task } : {}
 	};
 };
 const json = (body, status = 200) => Response.json(body, { status });
@@ -851,8 +876,9 @@ const createSurveyAssistantThreadHandlers = ({ authorize, onError, repository })
 			const identity = await authorize(request);
 			const cursor = new URL(request.url).searchParams.get("cursor")?.trim() || void 0;
 			const result = await repository.list(identity.resourceId, identity.metadata, { ...cursor ? { cursor } : {} });
+			const threads = (Array.isArray(result) ? result : result.threads).filter((thread) => ownsThread(thread, identity) && typeof thread.metadata?.archivedAt !== "string").map((thread) => asThread(thread, false));
 			return json({
-				threads: (Array.isArray(result) ? result : result.threads).filter((thread) => ownsThread(thread, identity) && typeof thread.metadata?.archivedAt !== "string").map(asThread),
+				threads,
 				...!Array.isArray(result) && result.nextCursor ? { nextCursor: result.nextCursor } : {}
 			});
 		} catch (error) {
@@ -864,18 +890,20 @@ const createSurveyAssistantThreadHandlers = ({ authorize, onError, repository })
 	};
 	const create = async (request) => {
 		try {
-			const [identity, input] = await Promise.all([authorize(request), readSurveyAssistantRequestJson(request, MAX_THREAD_MUTATION_BYTES)]);
+			const [identity, input] = await Promise.all([authorize(request), readSurveyAssistantRequestJson(request, MAX_THREAD_CREATE_BYTES)]);
 			const parsed = createSurveyAssistantThreadInputSchema.parse(input);
 			const metadata = { ...identity.metadata };
+			if (parsed.task) metadata[TASK_METADATA_KEY] = parsed.task;
 			if (parsed.title) {
 				metadata[MANUAL_TITLE_METADATA_KEY] = parsed.title;
 				metadata[AUTOMATIC_TITLE_METADATA_KEY] = DEFAULT_TITLE;
 			}
-			return json({ thread: asThread(await repository.create({
+			const thread = await repository.create({
 				resourceId: identity.resourceId,
 				title: parsed.title ?? DEFAULT_TITLE,
 				metadata
-			})) }, 201);
+			});
+			return json({ thread: asThread(thread) }, 201);
 		} catch (error) {
 			return errorResponse(error, onError, {
 				operation: "create",
@@ -923,11 +951,12 @@ const createSurveyAssistantThreadHandlers = ({ authorize, onError, repository })
 				metadata[MANUAL_TITLE_METADATA_KEY] = title;
 				metadata[AUTOMATIC_TITLE_METADATA_KEY] = automaticTitle;
 			}
-			return json({ thread: asThread(await repository.update({
+			const updated = await repository.update({
 				id: thread.id,
 				title,
 				metadata
-			})) });
+			});
+			return json({ thread: asThread(updated) });
 		} catch (error) {
 			return errorResponse(error, onError, {
 				operation: "update",
@@ -938,7 +967,8 @@ const createSurveyAssistantThreadHandlers = ({ authorize, onError, repository })
 	};
 	const deleteThread = async (request, threadId) => {
 		try {
-			const thread = await getOwnedThread(repository, await authorize(request), threadId);
+			const identity = await authorize(request);
+			const thread = await getOwnedThread(repository, identity, threadId);
 			if (!thread) return json({ error: "Chat not found." }, 404);
 			await repository.delete(thread.id);
 			return new Response(null, { status: 204 });
@@ -1029,4 +1059,4 @@ const createMastraMemoryThreadRepository = ({ getMemory, maxMessagesPerTranscrip
 //#endregion
 export { describeSurveyAssistantStreamError as a, loadSurveyAssistantDocuments as c, removeHistoricalSurveyAssistantAttachments as d, replaceCurrentSurveyAssistantAttachmentsWithReferences as f, createSurveyAssistantChatHandler as i, loadSurveyAssistantThreadAttachments as l, createSurveyAssistantThreadHandlers as n, formatSurveyAssistantStreamError as o, createSurveyAssistantTurnStream as p, SurveyAssistantAuthorizationError as r, getSurveyAssistantReplayableDocuments as s, createMastraMemoryThreadRepository as t, registerSurveyAssistantThreadAttachments as u };
 
-//# sourceMappingURL=memory-thread-repository-KWHQWFEW.mjs.map
+//# sourceMappingURL=memory-thread-repository-DmLadygY.mjs.map

package/dist/memory-thread-repository-DmLadygY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-thread-repository-DmLadygY.mjs","names":[],"sources":["../src/server/message-identity.ts","../src/server/execution-timeout.ts","../src/server/turn-stream.ts","../src/server/thread-documents.ts","../src/server/handler.ts","../src/server/thread-handlers.ts","../src/server/memory-thread-repository.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport type { UIMessage } from \"ai\";\n\n/** Bind client message ids to the host-authorized storage scope before Mastra's id-only upsert. */\nexport const scopeSurveyAssistantMessage = (\n  message: UIMessage,\n  identity: { resourceId: string; threadId: string },\n): UIMessage => {\n  const scope = createHash(\"sha256\")\n    .update(JSON.stringify([identity.resourceId, identity.threadId]))\n    .digest(\"hex\");\n  const prefix = `survey-user-${scope}-`;\n  // History reloads expose persisted ids. Only our own scope's user ids are\n  // already normalized; another resource/thread's ids are always re-scoped.\n  const id =\n    message.id.startsWith(prefix) && /^[a-f0-9]{64}$/.test(message.id.slice(prefix.length))\n      ? message.id\n      : `${prefix}${createHash(\"sha256\").update(message.id).digest(\"hex\")}`;\n  return { id, role: \"user\", parts: message.parts };\n};\n","import type { UIMessageChunk } from \"ai\";\n\nexport type SurveyAssistantExecutionTimeoutKind = \"first-response\" | \"idle\" | \"max-duration\";\n\nexport interface SurveyAssistantExecutionTimeoutOptions {\n  firstResponseTimeoutMs: number;\n  idleTimeoutMs: number;\n  maxDurationMs: number;\n  requestSignal: AbortSignal;\n}\n\nexport interface SurveyAssistantExecutionTimeout {\n  readonly signal: AbortSignal;\n  readonly timeoutKind: SurveyAssistantExecutionTimeoutKind | null;\n  dispose(): void;\n  recordActivity(): void;\n}\n\nconst timeoutMessages: Record<SurveyAssistantExecutionTimeoutKind, string> = {\n  \"first-response\": \"The survey assistant timed out while waiting for its first response.\",\n  idle: \"The survey assistant timed out after it stopped producing activity.\",\n  \"max-duration\": \"The survey assistant reached its maximum execution duration.\",\n};\n\nexport const getSurveyAssistantExecutionTimeoutMessage = (\n  kind: SurveyAssistantExecutionTimeoutKind,\n) => timeoutMessages[kind];\n\nexport const isSurveyAssistantExecutionActivityChunk = (chunk: UIMessageChunk): boolean =>\n  chunk.type !== \"start\" &&\n  chunk.type !== \"start-step\" &&\n  chunk.type !== \"finish\" &&\n  chunk.type !== \"finish-step\" &&\n  chunk.type !== \"abort\" &&\n  chunk.type !== \"error\";\n\nexport const createSurveyAssistantExecutionTimeout = ({\n  firstResponseTimeoutMs,\n  idleTimeoutMs,\n  maxDurationMs,\n  requestSignal,\n}: SurveyAssistantExecutionTimeoutOptions): SurveyAssistantExecutionTimeout => {\n  const timeoutController = new AbortController();\n  let activityTimer: ReturnType<typeof setTimeout> | undefined;\n  let hardCapTimer: ReturnType<typeof setTimeout> | undefined;\n  let timeoutKind: SurveyAssistantExecutionTimeoutKind | null = null;\n\n  const unrefTimer = (timer: ReturnType<typeof setTimeout>) => {\n    if (typeof timer === \"object\" && \"unref\" in timer) timer.unref();\n  };\n\n  const clearActivityTimer = () => {\n    if (activityTimer !== undefined) clearTimeout(activityTimer);\n    activityTimer = undefined;\n  };\n  const dispose = () => {\n    clearActivityTimer();\n    if (hardCapTimer !== undefined) clearTimeout(hardCapTimer);\n    hardCapTimer = undefined;\n  };\n  const abortForTimeout = (kind: SurveyAssistantExecutionTimeoutKind) => {\n    if (timeoutController.signal.aborted || requestSignal.aborted) return;\n    timeoutKind = kind;\n    dispose();\n    timeoutController.abort(\n      new DOMException(getSurveyAssistantExecutionTimeoutMessage(kind), \"TimeoutError\"),\n    );\n  };\n  const scheduleActivityTimeout = (\n    durationMs: number,\n    kind: Extract<SurveyAssistantExecutionTimeoutKind, \"first-response\" | \"idle\">,\n  ) => {\n    clearActivityTimer();\n    activityTimer = setTimeout(() => abortForTimeout(kind), durationMs);\n    unrefTimer(activityTimer);\n  };\n\n  if (!requestSignal.aborted) {\n    hardCapTimer = setTimeout(() => abortForTimeout(\"max-duration\"), maxDurationMs);\n    unrefTimer(hardCapTimer);\n    scheduleActivityTimeout(firstResponseTimeoutMs, \"first-response\");\n  }\n\n  const signal = AbortSignal.any([requestSignal, timeoutController.signal]);\n\n  return {\n    signal,\n    get timeoutKind() {\n      return timeoutKind;\n    },\n    dispose,\n    recordActivity() {\n      if (signal.aborted) return;\n      scheduleActivityTimeout(idleTimeoutMs, \"idle\");\n    },\n  };\n};\n","import {\n  SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE,\n  type SurveyAssistantTurnFinal,\n  type SurveyAssistantTurnTerminationReason,\n} from \"../protocol\";\nimport type { TurnSurveyDraft } from \"../engine\";\nimport type { UIMessageChunk } from \"ai\";\nimport { isSurveyAssistantExecutionActivityChunk } from \"./execution-timeout\";\n\nconst createTurnFinalChunk = (turnFinal: SurveyAssistantTurnFinal): UIMessageChunk => ({\n  type: SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE,\n  id: turnFinal.turnId,\n  data: turnFinal,\n});\n\nexport interface SurveyAssistantTurnStreamOptions {\n  stream: ReadableStream<UIMessageChunk>;\n  turnDraft: TurnSurveyDraft;\n  signal?: AbortSignal;\n  onUnexpectedError?: (error: unknown) => string;\n  onActivity?: () => void;\n  onSettled?: () => void;\n  getAbortErrorText?: () => string | undefined;\n  getAbortTerminationReason?: () => SurveyAssistantTurnTerminationReason | undefined;\n  turnStartedAt?: number;\n}\n\nconst getFinishTerminationReason = (\n  finishReason: Extract<UIMessageChunk, { type: \"finish\" }>[\"finishReason\"],\n): SurveyAssistantTurnTerminationReason => {\n  switch (finishReason) {\n    // The AI SDK reports the agent loop's step cap this way; it isn't a literal tool-call error.\n    case \"tool-calls\":\n      return \"max-steps\";\n    case \"length\":\n      return \"length-limit\";\n    case \"content-filter\":\n      return \"content-filter\";\n    case \"error\":\n      return \"provider-error\";\n    default:\n      return \"incomplete-response\";\n  }\n};\n\nexport const createSurveyAssistantTurnStream = ({\n  turnDraft,\n  getAbortErrorText,\n  getAbortTerminationReason,\n  onActivity,\n  onSettled,\n  onUnexpectedError = () => \"The survey assistant stream ended unexpectedly.\",\n  signal,\n  stream,\n  turnStartedAt,\n}: SurveyAssistantTurnStreamOptions): ReadableStream<UIMessageChunk> => {\n  const reader = stream.getReader();\n  let settled = false;\n\n  const settle = () => {\n    if (settled) {\n      return;\n    }\n    settled = true;\n    onSettled?.();\n  };\n\n  return new ReadableStream<UIMessageChunk>({\n    async start(controller) {\n      let emittedTurnFinal = false;\n      let sawFinish = false;\n      let emittedAbortError = false;\n      let finishReason: Extract<UIMessageChunk, { type: \"finish\" }>[\"finishReason\"];\n\n      const emitTurnFinal = (\n        status: SurveyAssistantTurnFinal[\"status\"],\n        terminationReason?: SurveyAssistantTurnTerminationReason,\n      ) => {\n        if (emittedTurnFinal) {\n          return;\n        }\n        emittedTurnFinal = true;\n        const completedAt = Date.now();\n        controller.enqueue(\n          createTurnFinalChunk(\n            turnDraft.finalize(status, new Date(completedAt).toISOString(), {\n              ...(turnStartedAt === undefined\n                ? {}\n                : {\n                    startedAt: new Date(turnStartedAt).toISOString(),\n                    durationMs: Math.max(0, completedAt - turnStartedAt),\n                  }),\n              ...(terminationReason ? { terminationReason } : {}),\n            }),\n          ),\n        );\n      };\n      const emitAbortOutcome = () => {\n        const errorText = getAbortErrorText?.();\n        emitTurnFinal(\n          errorText ? \"failed\" : \"aborted\",\n          getAbortTerminationReason?.() ?? (errorText ? \"incomplete-response\" : \"client-abort\"),\n        );\n        if (errorText && !emittedAbortError) {\n          emittedAbortError = true;\n          controller.enqueue({ type: \"error\", errorText });\n        }\n      };\n\n      try {\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) {\n            break;\n          }\n\n          if (isSurveyAssistantExecutionActivityChunk(value)) onActivity?.();\n\n          if (value.type === SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE) {\n            emitTurnFinal(\"failed\");\n            controller.enqueue({\n              type: \"error\",\n              errorText: \"The survey assistant returned an invalid duplicate turn final.\",\n            });\n            await reader.cancel(\"duplicate turn final\");\n            break;\n          }\n          if (value.type === \"error\") {\n            emitTurnFinal(\"failed\", \"provider-error\");\n            controller.enqueue(value);\n            continue;\n          }\n          if (value.type === \"abort\") {\n            const timeoutErrorText = getAbortErrorText?.();\n            emitAbortOutcome();\n            if (!timeoutErrorText) controller.enqueue(value);\n            continue;\n          }\n          if (value.type === \"finish\") {\n            sawFinish = true;\n            finishReason = value.finishReason;\n          }\n          controller.enqueue(value);\n        }\n\n        if (!emittedTurnFinal) {\n          if (signal?.aborted) {\n            emitAbortOutcome();\n          } else {\n            emitTurnFinal(\n              sawFinish && (finishReason === undefined || finishReason === \"stop\")\n                ? \"completed\"\n                : \"failed\",\n              sawFinish && finishReason !== undefined && finishReason !== \"stop\"\n                ? getFinishTerminationReason(finishReason)\n                : !sawFinish\n                  ? \"incomplete-response\"\n                  : undefined,\n            );\n          }\n        }\n        controller.close();\n      } catch (error) {\n        try {\n          if (signal?.aborted) emitAbortOutcome();\n          else emitTurnFinal(\"failed\", \"stream-error\");\n          if (!signal?.aborted) {\n            controller.enqueue({ type: \"error\", errorText: onUnexpectedError(error) });\n          }\n          controller.close();\n        } catch {\n          // The client disconnected; finalization still occurred server-side.\n        }\n      } finally {\n        reader.releaseLock();\n        settle();\n      }\n    },\n    async cancel(reason) {\n      const completedAt = Date.now();\n      turnDraft.finalize(\"aborted\", new Date(completedAt).toISOString(), {\n        ...(turnStartedAt === undefined\n          ? {}\n          : {\n              startedAt: new Date(turnStartedAt).toISOString(),\n              durationMs: Math.max(0, completedAt - turnStartedAt),\n            }),\n        terminationReason: \"client-abort\",\n      });\n      settle();\n      await reader.cancel(reason);\n    },\n  });\n};\n","import type { UIMessage } from \"ai\";\nimport { createHash } from \"node:crypto\";\nimport type { SurveyAssistantRequestLimits } from \"./request-guardrails\";\nimport {\n  SURVEY_ASSISTANT_ATTACHMENT_PART_TYPE,\n  type SurveyAssistantAttachmentReference,\n} from \"../protocol\";\n\nexport interface SurveyAssistantThreadDocument {\n  id: string;\n  name: string;\n  mediaType: string;\n  bytes: number;\n  contentHash: string;\n  createdAt: string;\n}\n\nexport interface SurveyAssistantThreadDocumentContent extends SurveyAssistantThreadDocument {\n  data: string;\n}\n\nexport interface SurveyAssistantModelAttachment {\n  filename: string;\n  mediaType: string;\n  data: string;\n  contentHash: string;\n}\n\nexport interface SurveyAssistantLoadedDocument extends SurveyAssistantModelAttachment {\n  documentId: string;\n}\n\nexport interface SurveyAssistantAttachmentAccess {\n  documents: SurveyAssistantThreadDocument[];\n  /** Attachments submitted in the current user message; already present as model context. */\n  currentDocumentIds?: string[];\n  /** Originals retained for every remaining model request in this turn. */\n  selectedAttachments: SurveyAssistantLoadedDocument[];\n  limits: Pick<\n    SurveyAssistantRequestLimits,\n    \"maxAttachments\" | \"maxAttachmentBytes\" | \"maxTotalAttachmentBytes\"\n  >;\n  /** Return only successfully loaded originals, each with its manifest document ID. */\n  load(documentIds: string[]): Promise<SurveyAssistantLoadedDocument[]>;\n}\n\nexport interface SurveyAssistantThreadDocumentRepository {\n  put(input: {\n    resourceId: string;\n    threadId: string;\n    name: string;\n    mediaType: string;\n    data: string;\n    bytes: number;\n  }): Promise<SurveyAssistantThreadDocument>;\n  list(input: { resourceId: string; threadId: string }): Promise<SurveyAssistantThreadDocument[]>;\n  read(input: {\n    resourceId: string;\n    threadId: string;\n    documentId: string;\n  }): Promise<SurveyAssistantThreadDocumentContent | null>;\n  deleteThread(input: { resourceId: string; threadId: string }): Promise<void>;\n}\n\nconst parseFileDataUrl = (url: string) => {\n  const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/.exec(url);\n  return match ? { mediaType: match[1], data: match[2] } : null;\n};\n\nconst getBase64Bytes = (data: string) => {\n  const padding = data.endsWith(\"==\") ? 2 : data.endsWith(\"=\") ? 1 : 0;\n  return Math.max(0, Math.floor((data.length * 3) / 4) - padding);\n};\n\nconst getAttachmentContentHash = (data: string) => createHash(\"sha256\").update(data).digest(\"hex\");\n\nconst createAttachmentReferencePart = ({\n  document,\n  filename,\n  mediaType,\n  parsedData,\n}: {\n  document?: SurveyAssistantThreadDocument;\n  filename?: string;\n  mediaType: string;\n  parsedData?: string;\n}) => ({\n  type: SURVEY_ASSISTANT_ATTACHMENT_PART_TYPE,\n  data: {\n    ...(document ? { documentId: document.id } : {}),\n    filename: filename?.trim() || document?.name || \"Attached document\",\n    mediaType: document?.mediaType || mediaType,\n    bytes: document?.bytes ?? (parsedData ? getBase64Bytes(parsedData) : 0),\n  } satisfies SurveyAssistantAttachmentReference,\n});\n\nconst createDocumentIndex = (documents: SurveyAssistantThreadDocument[]) =>\n  new Map(\n    documents.map((document) => [`${document.mediaType}\\u0000${document.contentHash}`, document]),\n  );\n\n/**\n * Replaces current-turn file data with small repository references before the\n * message is handed to Mastra for persistence. The provider-bound attachment\n * processor re-injects the authorized repository copy transiently.\n */\nexport const replaceCurrentSurveyAssistantAttachmentsWithReferences = ({\n  documents,\n  messages,\n}: {\n  documents: SurveyAssistantThreadDocument[];\n  messages: UIMessage[];\n}): UIMessage[] => {\n  const current = getCurrentUserMessage(messages);\n  if (!current) return messages;\n  const documentIndex = createDocumentIndex(documents);\n\n  return messages.map((message) => {\n    if (message !== current) return message;\n    let changed = false;\n    const parts = message.parts.map((part) => {\n      if (part.type !== \"file\") return part;\n      changed = true;\n      const parsed = typeof part.url === \"string\" ? parseFileDataUrl(part.url) : null;\n      const mediaType = parsed?.mediaType || part.mediaType;\n      const document = parsed\n        ? documentIndex.get(`${mediaType}\\u0000${getAttachmentContentHash(parsed.data)}`)\n        : undefined;\n      return createAttachmentReferencePart({\n        document,\n        filename: part.filename,\n        mediaType,\n        parsedData: parsed?.data,\n      });\n    });\n    return changed ? { ...message, parts } : message;\n  }) as UIMessage[];\n};\n\nexport const registerSurveyAssistantThreadAttachments = async ({\n  messages,\n  repository,\n  resourceId,\n  threadId,\n}: {\n  messages: UIMessage[];\n  repository: SurveyAssistantThreadDocumentRepository;\n  resourceId: string;\n  threadId: string;\n}) => {\n  const registered: SurveyAssistantThreadDocument[] = [];\n\n  const currentMessage = getCurrentUserMessage(messages);\n  for (const message of currentMessage ? [currentMessage] : []) {\n    for (const part of message.parts) {\n      if (part.type !== \"file\" || typeof part.url !== \"string\") continue;\n      const parsed = parseFileDataUrl(part.url);\n      if (!parsed) continue;\n\n      registered.push(\n        await repository.put({\n          resourceId,\n          threadId,\n          name: part.filename?.trim() || \"Attached document\",\n          mediaType: parsed.mediaType,\n          data: parsed.data,\n          bytes: getBase64Bytes(parsed.data),\n        }),\n      );\n    }\n  }\n\n  return registered;\n};\n\nconst getCurrentUserMessage = (messages: UIMessage[]) => {\n  for (let index = messages.length - 1; index >= 0; index -= 1) {\n    const message = messages[index];\n    if (message?.role === \"user\") return message;\n  }\n  return undefined;\n};\n\nexport const removeHistoricalSurveyAssistantAttachments = (messages: UIMessage[]) => {\n  const current = getCurrentUserMessage(messages);\n  return messages.map((message) => {\n    if (message === current) return message;\n    const parts = message.parts.filter((part) => part.type !== \"file\");\n    return parts.length === message.parts.length ? message : { ...message, parts };\n  });\n};\n\n/**\n * Excludes the exact repository documents already loaded for the current turn.\n * Message parts are references by this stage and are not a deduplication source.\n */\nexport const getSurveyAssistantReplayableDocuments = (\n  documents: SurveyAssistantThreadDocument[],\n  currentDocumentIds: ReadonlySet<string>,\n) => documents.filter((document) => !currentDocumentIds.has(document.id));\n\nexport const loadSurveyAssistantThreadAttachments = async ({\n  currentDocumentIds = new Set<string>(),\n  documents,\n  repository,\n  resourceId,\n  threadId,\n}: {\n  currentDocumentIds?: ReadonlySet<string>;\n  documents: SurveyAssistantThreadDocument[];\n  repository: SurveyAssistantThreadDocumentRepository;\n  resourceId: string;\n  threadId: string;\n}): Promise<SurveyAssistantLoadedDocument[]> => {\n  const replayableDocuments = getSurveyAssistantReplayableDocuments(documents, currentDocumentIds);\n\n  return loadSurveyAssistantDocuments({\n    documents: replayableDocuments,\n    repository,\n    resourceId,\n    threadId,\n  });\n};\n\nexport const loadSurveyAssistantDocuments = async ({\n  documents,\n  repository,\n  resourceId,\n  threadId,\n}: {\n  documents: SurveyAssistantThreadDocument[];\n  repository: SurveyAssistantThreadDocumentRepository;\n  resourceId: string;\n  threadId: string;\n}): Promise<SurveyAssistantLoadedDocument[]> => {\n  const attachments: SurveyAssistantLoadedDocument[] = [];\n  for (const document of documents) {\n    const content = await repository.read({\n      resourceId,\n      threadId,\n      documentId: document.id,\n    });\n    if (!content) continue;\n    attachments.push({\n      documentId: document.id,\n      filename: content.name,\n      mediaType: content.mediaType,\n      data: content.data,\n      contentHash: content.contentHash,\n    });\n  }\n\n  return attachments;\n};\n","import { scopeSurveyAssistantMessage } from \"./message-identity\";\nimport { handleChatStream } from \"@mastra/ai-sdk\";\nimport type { AgentExecutionOptions } from \"@mastra/core/agent\";\nimport type { Mastra } from \"@mastra/core/mastra\";\nimport { createUIMessageStreamResponse, type UIMessage, type UIMessageChunk } from \"ai\";\nimport {\n  SurveyAssistantCapabilityMismatchError,\n  TurnSurveyDraft,\n  type SurveyAssistantCapabilitySet,\n} from \"../engine\";\nimport {\n  isSurveyAssistantErrorRetryable,\n  MAX_USER_ERROR_MESSAGE_LENGTH,\n  sanitizeSurveyAssistantDiagnosticText,\n  serializeSurveyAssistantError,\n  type SurveyAssistantErrorCode,\n  type SurveyAssistantTurnTerminationReason,\n  type SurveyDocumentSnapshot,\n} from \"../protocol\";\nimport {\n  buildSurveyAssistantRequestContext,\n  parseSurveyAssistantPreviousApplyOutcome,\n  parseSurveyAssistantPreviousSettledVersion,\n  parseSurveyAssistantSnapshot,\n  type SurveyAssistantModelSelection,\n  type SurveyAssistantIdentityContext,\n} from \"./request-context\";\nimport { SURVEY_ASSISTANT_AGENT_ID } from \"./constants\";\nimport {\n  readSurveyAssistantRequestJson,\n  SurveyAssistantRequestError,\n  SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS,\n  type SurveyAssistantRequestLimits,\n  validateSurveyAssistantMessages,\n} from \"./request-guardrails\";\nimport { createSurveyAssistantTurnStream } from \"./turn-stream\";\nimport {\n  createSurveyAssistantExecutionTimeout,\n  getSurveyAssistantExecutionTimeoutMessage,\n  type SurveyAssistantExecutionTimeoutKind,\n} from \"./execution-timeout\";\nimport {\n  registerSurveyAssistantThreadAttachments,\n  loadSurveyAssistantDocuments,\n  getSurveyAssistantReplayableDocuments,\n  removeHistoricalSurveyAssistantAttachments,\n  replaceCurrentSurveyAssistantAttachmentsWithReferences,\n  type SurveyAssistantAttachmentAccess,\n  type SurveyAssistantModelAttachment,\n  type SurveyAssistantThreadDocumentRepository,\n} from \"./thread-documents\";\n\nconst DEFAULT_MAX_STEPS = 48;\nconst DEFAULT_MAX_CONCURRENT_REQUESTS = 8;\nconst DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 15 * 60 * 1_000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1_000;\nconst DEFAULT_MAX_DURATION_MS = 60 * 60 * 1_000;\nconst MAX_ERROR_CAUSE_DEPTH = 5;\n\ntype ProviderOptions = AgentExecutionOptions[\"providerOptions\"];\n\nconst getTimeoutTerminationReason = (\n  kind: SurveyAssistantExecutionTimeoutKind,\n): SurveyAssistantTurnTerminationReason => {\n  switch (kind) {\n    case \"first-response\":\n      return \"first-response-timeout\";\n    case \"idle\":\n      return \"idle-timeout\";\n    case \"max-duration\":\n      return \"max-duration\";\n  }\n};\n\nexport interface SurveyAssistantAuthorizationInput {\n  request: Request;\n  requestedResourceId?: string;\n  requestedThreadId?: string;\n  requestedSurveyId?: string;\n}\n\nexport type SurveyAssistantAuthorizedIdentity = SurveyAssistantIdentityContext;\n\nexport type SurveyAssistantAuthorize = (\n  input: SurveyAssistantAuthorizationInput,\n) => Promise<SurveyAssistantAuthorizedIdentity> | SurveyAssistantAuthorizedIdentity;\n\nexport interface SurveyAssistantModelResolutionInput {\n  identity: SurveyAssistantAuthorizedIdentity;\n  request: Request;\n  requestedModelId?: string;\n}\n\nexport type SurveyAssistantResolveModel = (\n  input: SurveyAssistantModelResolutionInput,\n) =>\n  | Promise<SurveyAssistantModelSelection | null | undefined>\n  | SurveyAssistantModelSelection\n  | null\n  | undefined;\n\nexport class SurveyAssistantAuthorizationError extends Error {\n  readonly status: number;\n\n  constructor(message = \"The survey assistant request is not authorized.\", status = 403) {\n    super(message);\n    this.name = \"SurveyAssistantAuthorizationError\";\n    this.status = status;\n  }\n}\n\nexport interface SurveyAssistantTurnMetrics {\n  durationMs?: number;\n  snapshotBytes: number;\n  toolCalls: number;\n  inputTokens?: number;\n  outputTokens?: number;\n  totalTokens?: number;\n  reasoningTokens?: number;\n  cachedInputTokens?: number;\n  terminationReason?: SurveyAssistantTurnTerminationReason;\n}\n\nexport interface SurveyAssistantStreamErrorContext {\n  requestId?: string;\n  resourceId: string;\n  surveyId?: string;\n  threadId: string;\n}\n\nexport interface SurveyAssistantChatHandlerOptions {\n  mastra: Mastra | (() => Mastra | Promise<Mastra>);\n  authorize: SurveyAssistantAuthorize;\n  activeTools: readonly string[];\n  agentId?: string;\n  trustedCapabilities?: SurveyAssistantCapabilitySet;\n  isEnabled?: (request: Request) => boolean | Promise<boolean>;\n  getReadinessError?: (request: Request) => string | null | Promise<string | null>;\n  firstResponseTimeoutMs?: number;\n  idleTimeoutMs?: number;\n  maxConcurrentRequests?: number;\n  maxDurationMs?: number;\n  maxSteps?: number;\n  providerName?: string;\n  providerOptions?: ProviderOptions;\n  sendReasoning?: boolean;\n  formatStreamError?: (error: unknown, context: SurveyAssistantStreamErrorContext) => string;\n  onStreamError?: (error: unknown, context: SurveyAssistantStreamErrorContext) => void;\n  onTurnMetrics?: (input: {\n    identity: SurveyAssistantAuthorizedIdentity;\n    metrics: SurveyAssistantTurnMetrics;\n    provider?: string;\n    requestId?: string;\n    turnId: string;\n  }) => void;\n  /** Optional overrides; omitted values use the safe package defaults. */\n  requestLimits?: Partial<SurveyAssistantRequestLimits>;\n  resolveModel?: SurveyAssistantResolveModel;\n  threadDocuments?: SurveyAssistantThreadDocumentRepository;\n}\n\ntype SurveyAssistantChatParams = {\n  messages?: unknown;\n  snapshot?: unknown;\n  previousSettledVersion?: unknown;\n  previousApplyOutcome?: unknown;\n  requestId?: unknown;\n  id?: unknown;\n  resourceId?: unknown;\n  modelId?: unknown;\n  threadId?: unknown;\n  surveyId?: unknown;\n  trigger?: \"submit-message\" | \"regenerate-message\";\n} & Record<string, unknown>;\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst optionalRequestedId = (value: unknown) => {\n  if (typeof value !== \"string\") return undefined;\n  const normalized = value.trim();\n  return normalized.length > 0 && normalized.length <= 240 ? normalized : undefined;\n};\n\nconst optionalDiagnosticId = (value: unknown) => {\n  if (typeof value !== \"string\") return undefined;\n  const normalized = value.trim();\n  return /^[A-Za-z0-9_-]{8,64}$/.test(normalized) ? normalized : undefined;\n};\n\nconst validateAuthorizedIdentity = (\n  identity: SurveyAssistantAuthorizedIdentity,\n): SurveyAssistantAuthorizedIdentity => {\n  if (\n    !identity ||\n    (identity.authority !== \"authenticated-host\" &&\n      identity.authority !== \"experimental-client-request\") ||\n    typeof identity.resourceId !== \"string\" ||\n    identity.resourceId.trim().length === 0 ||\n    identity.resourceId.length > 240 ||\n    (identity.surveyId !== undefined && !optionalRequestedId(identity.surveyId)) ||\n    typeof identity.threadId !== \"string\" ||\n    identity.threadId.trim().length === 0 ||\n    identity.threadId.length > 240\n  ) {\n    throw new SurveyAssistantAuthorizationError(\n      \"The host returned an invalid survey assistant identity.\",\n      500,\n    );\n  }\n\n  return {\n    authority: identity.authority,\n    resourceId: identity.resourceId.trim(),\n    ...(identity.surveyId ? { surveyId: optionalRequestedId(identity.surveyId) } : {}),\n    threadId: identity.threadId.trim(),\n  };\n};\n\nconst validateModelSelection = (\n  selection: SurveyAssistantModelSelection | null | undefined,\n): SurveyAssistantModelSelection | null => {\n  if (!selection) return null;\n  const id = optionalRequestedId(selection.id);\n  const modelValue: unknown = selection.model;\n  const stringModel = typeof modelValue === \"string\" ? optionalRequestedId(modelValue) : undefined;\n  const objectModel = (() => {\n    if (!isRecord(modelValue)) return undefined;\n    const url = modelValue.url;\n    const apiKey = modelValue.apiKey;\n    const headers = modelValue.headers;\n    if (\n      (url !== undefined && typeof url !== \"string\") ||\n      (apiKey !== undefined && typeof apiKey !== \"string\") ||\n      (headers !== undefined &&\n        (!isRecord(headers) || Object.values(headers).some((value) => typeof value !== \"string\")))\n    ) {\n      return undefined;\n    }\n    const shared = {\n      ...(url === undefined ? {} : { url }),\n      ...(apiKey === undefined ? {} : { apiKey }),\n      ...(headers === undefined ? {} : { headers: headers as Record<string, string> }),\n    };\n    const compatibleId = optionalRequestedId(modelValue.id);\n    if (compatibleId) {\n      return { id: compatibleId, ...shared } as SurveyAssistantModelSelection[\"model\"];\n    }\n    const providerId = optionalRequestedId(modelValue.providerId);\n    const modelId = optionalRequestedId(modelValue.modelId);\n    if (providerId && modelId) {\n      return {\n        providerId,\n        modelId,\n        ...shared,\n      } as SurveyAssistantModelSelection[\"model\"];\n    }\n    return undefined;\n  })();\n  const providerName =\n    selection.providerName === undefined ? undefined : optionalRequestedId(selection.providerName);\n  const providerOptions = selection.providerOptions;\n  if (\n    (selection.providerName !== undefined && !providerName) ||\n    (providerOptions !== undefined && !isRecord(providerOptions))\n  ) {\n    return null;\n  }\n  return id && (stringModel || objectModel)\n    ? {\n        id,\n        model: stringModel ?? objectModel!,\n        ...(providerName ? { providerName } : {}),\n        ...(providerOptions ? { providerOptions } : {}),\n      }\n    : null;\n};\n\nconst readNumber = (value: unknown): number | undefined =>\n  typeof value === \"number\" && Number.isFinite(value) ? value : undefined;\n\nconst recordTurnStreamPart = (metrics: SurveyAssistantTurnMetrics, part: unknown) => {\n  if (!isRecord(part)) return;\n  if (part.type === \"tool-call\") metrics.toolCalls += 1;\n  if (part.type !== \"finish\") return;\n\n  const payload = isRecord(part.payload) ? part.payload : undefined;\n  const output = isRecord(payload?.output) ? payload.output : undefined;\n  const usage = isRecord(output?.usage) ? output.usage : undefined;\n  if (!usage) return;\n\n  metrics.inputTokens = readNumber(usage.inputTokens);\n  metrics.outputTokens = readNumber(usage.outputTokens);\n  metrics.totalTokens = readNumber(usage.totalTokens);\n  metrics.reasoningTokens = readNumber(usage.reasoningTokens);\n  metrics.cachedInputTokens = readNumber(usage.cachedInputTokens);\n};\n\nconst unwrapStreamError = (error: unknown) => {\n  if (isRecord(error) && error.error !== undefined) return error.error;\n  return error;\n};\n\nconst describeErrorLevel = (value: unknown): Record<string, unknown> => {\n  if (value instanceof Error) {\n    const properties = Object.fromEntries(\n      Object.getOwnPropertyNames(value)\n        .filter((key) => key !== \"stack\")\n        .map((key) => [key, (value as unknown as Record<string, unknown>)[key]]),\n    );\n    return { name: value.name, message: value.message, stack: value.stack, ...properties };\n  }\n\n  if (isRecord(value)) {\n    return {\n      constructorName: value.constructor?.name,\n      ...Object.fromEntries(Object.getOwnPropertyNames(value).map((key) => [key, value[key]])),\n    };\n  }\n\n  return { value };\n};\n\nexport const describeSurveyAssistantStreamError = (error: unknown) => {\n  const levels: Record<string, unknown>[] = [];\n  let current: unknown = unwrapStreamError(error);\n\n  for (\n    let depth = 0;\n    depth < MAX_ERROR_CAUSE_DEPTH && current !== undefined && current !== null;\n    depth += 1\n  ) {\n    const level = describeErrorLevel(current);\n    levels.push(level);\n    current = level.cause;\n  }\n\n  return levels.length === 1 ? levels[0] : { levels };\n};\n\nconst clampUserErrorMessage = (message: string) => {\n  return sanitizeSurveyAssistantDiagnosticText(message, MAX_USER_ERROR_MESSAGE_LENGTH);\n};\n\nconst getProviderModelName = (message: string) =>\n  message.match(/\\bmodel\\s+[`'\"]([^`'\"]+)[`'\"]/i)?.[1]?.trim();\n\nconst classifyStreamError = (message: string, statusCode?: number): SurveyAssistantErrorCode => {\n  if (statusCode === 401 || statusCode === 403) return \"authorization_failed\";\n  if (statusCode === 429) return \"rate_limited\";\n  if (\n    /\\bmodel\\b[\\s\\S]{0,160}\\b(?:limited preview|not available)\\b/i.test(message) ||\n    /\\blimited preview\\b[\\s\\S]{0,160}\\bmodel\\b/i.test(message)\n  ) {\n    return \"model_unavailable\";\n  }\n  if (/\\b(?:rate limit|too many requests|request limit)\\b/i.test(message)) {\n    return \"rate_limited\";\n  }\n  if (\n    /\\b(?:invalid api key|incorrect api key|authentication|unauthorized|forbidden)\\b/i.test(message)\n  ) {\n    return \"authorization_failed\";\n  }\n  if (\n    /\\b(?:attachment|document|file)\\b[\\s\\S]{0,120}\\b(?:missing|unavailable|not found|failed)\\b/i.test(\n      message,\n    )\n  ) {\n    return \"attachment_unavailable\";\n  }\n  return \"request_failed\";\n};\n\nconst formatKnownProviderError = (message: string) => {\n  const normalized = clampUserErrorMessage(message);\n  if (\n    /\\bmodel\\b[\\s\\S]{0,160}\\b(?:limited preview|not available)\\b/i.test(normalized) ||\n    /\\blimited preview\\b[\\s\\S]{0,160}\\bmodel\\b/i.test(normalized)\n  ) {\n    const modelName = getProviderModelName(normalized);\n    return `The configured model${modelName ? ` \\`${modelName}\\`` : \"\"} is not available on this account.`;\n  }\n  if (/\\b(?:rate limit|too many requests|request limit)\\b/i.test(normalized)) {\n    return \"The AI provider is temporarily limiting requests.\";\n  }\n  if (\n    /\\b(?:invalid api key|incorrect api key|authentication|unauthorized|forbidden)\\b/i.test(\n      normalized,\n    )\n  ) {\n    return \"The AI provider rejected the assistant credentials.\";\n  }\n  return \"The AI provider could not complete the request.\";\n};\n\nconst parseProviderResponseBodyMessage = (responseBody: unknown) => {\n  if (typeof responseBody !== \"string\" || responseBody.trim().length === 0) return undefined;\n  try {\n    const parsed = JSON.parse(responseBody) as unknown;\n    if (isRecord(parsed) && isRecord(parsed.error) && typeof parsed.error.message === \"string\") {\n      return parsed.error.message;\n    }\n  } catch {\n    return undefined;\n  }\n  return undefined;\n};\n\nconst getProviderRequestId = (levels: unknown[]): string | undefined => {\n  for (const level of levels) {\n    if (!isRecord(level) || !isRecord(level.responseHeaders)) continue;\n    for (const [key, value] of Object.entries(level.responseHeaders)) {\n      const normalizedKey = key.toLocaleLowerCase();\n      if (\n        (normalizedKey === \"request-id\" || normalizedKey === \"x-request-id\") &&\n        typeof value === \"string\"\n      ) {\n        const normalized = sanitizeSurveyAssistantDiagnosticText(value, 240);\n        if (normalized) return normalized;\n      }\n    }\n  }\n  return undefined;\n};\n\nconst extractUserErrorMessageFromLevel = (level: Record<string, unknown>) => {\n  if (\n    isRecord(level.data) &&\n    isRecord(level.data.error) &&\n    typeof level.data.error.message === \"string\"\n  ) {\n    return level.data.error.message;\n  }\n  return (\n    parseProviderResponseBodyMessage(level.responseBody) ??\n    (typeof level.message === \"string\" ? level.message : undefined)\n  );\n};\n\nconst isProviderCallErrorLevel = (level: Record<string, unknown>) =>\n  level.constructorName === \"APICallError\" ||\n  level.name === \"AI_APICallError\" ||\n  (level.statusCode !== undefined &&\n    (level.responseBody !== undefined || level.responseHeaders !== undefined));\n\nexport const formatSurveyAssistantStreamError = (error: unknown) => {\n  const describedError = describeSurveyAssistantStreamError(error);\n  const levels = Array.isArray(describedError.levels) ? describedError.levels : [describedError];\n  const messageLevel = levels.find(\n    (level): level is Record<string, unknown> =>\n      isRecord(level) && Boolean(extractUserErrorMessageFromLevel(level)),\n  );\n  const statusLevel = levels.find(\n    (level): level is Record<string, unknown> => isRecord(level) && level.statusCode !== undefined,\n  );\n  const statusCode = Number(statusLevel?.statusCode);\n  const detail = messageLevel ? extractUserErrorMessageFromLevel(messageLevel) : undefined;\n  const providerLevel = levels.find(\n    (level): level is Record<string, unknown> => isRecord(level) && isProviderCallErrorLevel(level),\n  );\n  const providerDetail = providerLevel\n    ? extractUserErrorMessageFromLevel(providerLevel)\n    : undefined;\n  const formattedDetail = detail ? formatKnownProviderError(detail) : undefined;\n  const code = classifyStreamError(\n    detail ?? formattedDetail ?? \"\",\n    Number.isFinite(statusCode) ? statusCode : undefined,\n  );\n  const providerMessage =\n    code === \"authorization_failed\" || !providerDetail\n      ? undefined\n      : sanitizeSurveyAssistantDiagnosticText(providerDetail, MAX_USER_ERROR_MESSAGE_LENGTH);\n  const upstreamStatus = Number.isFinite(statusCode) ? statusCode : undefined;\n  const providerRequestId = getProviderRequestId(levels);\n  return serializeSurveyAssistantError({\n    code,\n    ...(formattedDetail ? { detail: formattedDetail } : {}),\n    ...(upstreamStatus ? { upstreamStatus } : {}),\n    ...(providerRequestId ? { providerRequestId } : {}),\n    ...(providerMessage ? { providerMessage } : {}),\n    retryable: isSurveyAssistantErrorRetryable({ code, upstreamStatus }),\n  });\n};\n\nconst requestErrorResponse = (error: unknown, fallback: string) => {\n  const requestError =\n    error instanceof SurveyAssistantRequestError\n      ? error\n      : new SurveyAssistantRequestError(fallback);\n  return Response.json(\n    { code: \"request_failed\", error: requestError.message },\n    { status: requestError.status },\n  );\n};\n\nexport const createSurveyAssistantChatHandler = (options: SurveyAssistantChatHandlerOptions) => {\n  const requestLimits: SurveyAssistantRequestLimits = {\n    ...SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS,\n    ...options.requestLimits,\n  };\n  for (const [name, value] of Object.entries(requestLimits)) {\n    if (\n      name !== \"acceptedAttachmentTypes\" &&\n      (!Number.isSafeInteger(value) || (value as number) <= 0)\n    ) {\n      throw new Error(`Survey assistant request limit \"${name}\" must be a positive integer.`);\n    }\n  }\n  if (typeof requestLimits.acceptedAttachmentTypes?.has !== \"function\") {\n    throw new Error(\"Survey assistant accepted attachment types must be a set.\");\n  }\n  const maxConcurrentRequests =\n    Number.isInteger(options.maxConcurrentRequests) && (options.maxConcurrentRequests ?? 0) > 0\n      ? options.maxConcurrentRequests!\n      : DEFAULT_MAX_CONCURRENT_REQUESTS;\n  const firstResponseTimeoutMs =\n    Number.isFinite(options.firstResponseTimeoutMs) && (options.firstResponseTimeoutMs ?? 0) > 0\n      ? options.firstResponseTimeoutMs!\n      : DEFAULT_FIRST_RESPONSE_TIMEOUT_MS;\n  const idleTimeoutMs =\n    Number.isFinite(options.idleTimeoutMs) && (options.idleTimeoutMs ?? 0) > 0\n      ? options.idleTimeoutMs!\n      : DEFAULT_IDLE_TIMEOUT_MS;\n  const maxSteps =\n    Number.isInteger(options.maxSteps) && (options.maxSteps ?? 0) > 0\n      ? options.maxSteps!\n      : DEFAULT_MAX_STEPS;\n  const maxDurationMs =\n    Number.isFinite(options.maxDurationMs) && (options.maxDurationMs ?? 0) > 0\n      ? options.maxDurationMs!\n      : DEFAULT_MAX_DURATION_MS;\n  let activeRequestCount = 0;\n\n  const acquireRequestSlot = () => {\n    if (activeRequestCount >= maxConcurrentRequests) return null;\n    activeRequestCount += 1;\n    let released = false;\n    return () => {\n      if (released) return;\n      released = true;\n      activeRequestCount = Math.max(0, activeRequestCount - 1);\n    };\n  };\n\n  return async (request: Request): Promise<Response> => {\n    if (options.isEnabled && !(await options.isEnabled(request))) {\n      return Response.json(\n        { code: \"authorization_failed\", error: \"Survey assistant is disabled.\" },\n        { status: 404 },\n      );\n    }\n\n    let rawParams: unknown;\n    try {\n      rawParams = await readSurveyAssistantRequestJson(request, requestLimits.maxRequestBytes);\n    } catch (error) {\n      return requestErrorResponse(error, \"The survey assistant request could not be read.\");\n    }\n\n    const params = isRecord(rawParams)\n      ? (rawParams as SurveyAssistantChatParams)\n      : ({} satisfies SurveyAssistantChatParams);\n    const requestId = optionalDiagnosticId(params.requestId);\n\n    let identity: SurveyAssistantAuthorizedIdentity;\n    try {\n      identity = validateAuthorizedIdentity(\n        await options.authorize({\n          request,\n          requestedResourceId: optionalRequestedId(params.resourceId),\n          requestedThreadId: optionalRequestedId(params.threadId ?? params.id),\n          requestedSurveyId: optionalRequestedId(params.surveyId),\n        }),\n      );\n    } catch (error) {\n      const authorizationError =\n        error instanceof SurveyAssistantAuthorizationError\n          ? error\n          : new SurveyAssistantAuthorizationError();\n      return Response.json(\n        { code: \"authorization_failed\", error: authorizationError.message },\n        { status: authorizationError.status },\n      );\n    }\n\n    let messages: UIMessage[];\n    try {\n      messages = validateSurveyAssistantMessages(params.messages, requestLimits).map((message) =>\n        scopeSurveyAssistantMessage(message, identity),\n      );\n    } catch (error) {\n      return requestErrorResponse(error, \"The survey assistant messages are invalid.\");\n    }\n\n    let modelSelection: SurveyAssistantModelSelection | undefined;\n    if (options.resolveModel) {\n      const requestedModelId = optionalRequestedId(params.modelId);\n      if (params.modelId !== undefined && !requestedModelId) {\n        return Response.json(\n          { code: \"model_unavailable\", error: \"Invalid survey assistant model selection.\" },\n          { status: 400 },\n        );\n      }\n\n      try {\n        modelSelection =\n          validateModelSelection(\n            await options.resolveModel({ identity, request, requestedModelId }),\n          ) ?? undefined;\n      } catch (error) {\n        options.onStreamError?.(error, {\n          requestId,\n          resourceId: identity.resourceId,\n          surveyId: identity.surveyId,\n          threadId: identity.threadId,\n        });\n        return Response.json(\n          {\n            code: \"model_unavailable\",\n            error: \"The survey assistant model catalog is unavailable.\",\n          },\n          { status: 503 },\n        );\n      }\n      if (!modelSelection) {\n        return Response.json(\n          {\n            code: \"model_unavailable\",\n            error: \"The selected survey assistant model is not available.\",\n          },\n          { status: 400 },\n        );\n      }\n    }\n\n    let snapshot: SurveyDocumentSnapshot | null;\n    let previousSettledVersion;\n    let previousApplyOutcome;\n    try {\n      snapshot = parseSurveyAssistantSnapshot(params.snapshot);\n      previousSettledVersion = parseSurveyAssistantPreviousSettledVersion(\n        params.previousSettledVersion,\n      );\n      previousApplyOutcome = parseSurveyAssistantPreviousApplyOutcome(params.previousApplyOutcome);\n    } catch {\n      return Response.json(\n        { code: \"request_failed\", error: \"Invalid survey assistant document context.\" },\n        { status: 400 },\n      );\n    }\n\n    const readinessError = await options.getReadinessError?.(request);\n    if (readinessError) {\n      return Response.json({ code: \"request_failed\", error: readinessError }, { status: 503 });\n    }\n\n    const releaseRequestSlot = acquireRequestSlot();\n    if (!releaseRequestSlot) {\n      return Response.json(\n        {\n          code: \"rate_limited\",\n          error: \"The survey assistant is handling too many requests. Try again shortly.\",\n        },\n        { status: 429 },\n      );\n    }\n\n    const turnDraft = new TurnSurveyDraft();\n    let requestContext;\n    try {\n      let attachmentAccess: SurveyAssistantAttachmentAccess | undefined;\n      let modelAttachments: SurveyAssistantModelAttachment[] = [];\n      if (options.threadDocuments) {\n        const repository = options.threadDocuments;\n        const registered = await registerSurveyAssistantThreadAttachments({\n          messages,\n          repository,\n          resourceId: identity.resourceId,\n          threadId: identity.threadId,\n        });\n        const manifest = await repository.list({\n          resourceId: identity.resourceId,\n          threadId: identity.threadId,\n        });\n        modelAttachments = await loadSurveyAssistantDocuments({\n          documents: registered,\n          repository,\n          resourceId: identity.resourceId,\n          threadId: identity.threadId,\n        });\n        messages = replaceCurrentSurveyAssistantAttachmentsWithReferences({\n          documents: registered,\n          messages,\n        });\n        messages = removeHistoricalSurveyAssistantAttachments(messages);\n        const registeredIds = new Set(registered.map((document) => document.id));\n        const replayableDocuments = getSurveyAssistantReplayableDocuments(manifest, registeredIds);\n        const documents = [...registered, ...replayableDocuments];\n        if (documents.length > 0) {\n          attachmentAccess = {\n            documents,\n            currentDocumentIds: registered.map((document) => document.id),\n            selectedAttachments: [],\n            limits: requestLimits,\n            load: (documentIds) =>\n              loadSurveyAssistantDocuments({\n                documents: documents.filter((document) => documentIds.includes(document.id)),\n                repository,\n                resourceId: identity.resourceId,\n                threadId: identity.threadId,\n              }),\n          };\n        }\n      }\n      requestContext = buildSurveyAssistantRequestContext({\n        turnDraft,\n        identity,\n        snapshot,\n        previousSettledVersion,\n        previousApplyOutcome,\n        trustedCapabilities: options.trustedCapabilities,\n        attachmentAccess,\n        modelAttachments,\n        modelSelection,\n      });\n    } catch (error) {\n      releaseRequestSlot();\n      if (error instanceof SurveyAssistantRequestError) {\n        return requestErrorResponse(error, \"The thread attachments could not be prepared.\");\n      }\n      if (error instanceof SurveyAssistantCapabilityMismatchError) {\n        return Response.json({ error: error.message, code: error.code }, { status: 409 });\n      }\n      options.onStreamError?.(error, {\n        requestId,\n        resourceId: identity.resourceId,\n        surveyId: identity.surveyId,\n        threadId: identity.threadId,\n      });\n      return Response.json(\n        {\n          code: \"attachment_unavailable\",\n          error: \"The survey assistant could not prepare the thread's reference documents.\",\n        },\n        { status: 503 },\n      );\n    }\n\n    const metrics: SurveyAssistantTurnMetrics = {\n      snapshotBytes: snapshot ? new TextEncoder().encode(JSON.stringify(snapshot)).byteLength : 0,\n      toolCalls: 0,\n    };\n    const streamErrorContext = {\n      requestId,\n      resourceId: identity.resourceId,\n      surveyId: identity.surveyId,\n      threadId: identity.threadId,\n    };\n    const executionStartedAt = Date.now();\n    const executionTimeout = createSurveyAssistantExecutionTimeout({\n      firstResponseTimeoutMs,\n      idleTimeoutMs,\n      maxDurationMs,\n      requestSignal: request.signal,\n    });\n    const executionSignal = executionTimeout.signal;\n    const finalizeExecutionTurn = (\n      status: \"completed\" | \"failed\" | \"aborted\",\n      terminationReason?: SurveyAssistantTurnTerminationReason,\n    ) => {\n      const completedAt = Date.now();\n      return turnDraft.finalize(status, new Date(completedAt).toISOString(), {\n        startedAt: new Date(executionStartedAt).toISOString(),\n        durationMs: Math.max(0, completedAt - executionStartedAt),\n        ...(terminationReason ? { terminationReason } : {}),\n      });\n    };\n    const handleStreamError = (error: unknown) => {\n      options.onStreamError?.(error, streamErrorContext);\n      return (\n        options.formatStreamError?.(error, streamErrorContext) ??\n        formatSurveyAssistantStreamError(error)\n      );\n    };\n\n    let stream: ReadableStream<UIMessageChunk>;\n    try {\n      const mastra = typeof options.mastra === \"function\" ? await options.mastra() : options.mastra;\n      stream = (await handleChatStream({\n        mastra,\n        agentId: options.agentId ?? SURVEY_ASSISTANT_AGENT_ID,\n        version: \"v6\",\n        params: {\n          messages,\n          ...(params.trigger ? { trigger: params.trigger } : {}),\n          requestContext,\n          runId: turnDraft.turnId,\n          abortSignal: executionSignal,\n          onAbort: () => {\n            finalizeExecutionTurn(\n              executionTimeout.timeoutKind ? \"failed\" : \"aborted\",\n              executionTimeout.timeoutKind\n                ? getTimeoutTerminationReason(executionTimeout.timeoutKind)\n                : \"client-abort\",\n            );\n          },\n          onError: () => {\n            finalizeExecutionTurn(\"failed\", \"provider-error\");\n          },\n          memory: {\n            thread: identity.threadId,\n            resource: identity.resourceId,\n          },\n        },\n        defaultOptions: {\n          activeTools: [...options.activeTools],\n          maxSteps,\n          ...((modelSelection?.providerOptions ?? options.providerOptions)\n            ? { providerOptions: modelSelection?.providerOptions ?? options.providerOptions }\n            : {}),\n        },\n        sendReasoning: options.sendReasoning ?? true,\n        messageMetadata: ({ part }: { part: unknown }) => {\n          recordTurnStreamPart(metrics, part);\n          return undefined;\n        },\n        onError: (error: unknown) => {\n          finalizeExecutionTurn(\"failed\", \"provider-error\");\n          return handleStreamError(error);\n        },\n      } as never)) as ReadableStream<UIMessageChunk>;\n    } catch (error) {\n      finalizeExecutionTurn(\n        executionTimeout.timeoutKind ? \"failed\" : executionSignal.aborted ? \"aborted\" : \"failed\",\n        executionTimeout.timeoutKind\n          ? getTimeoutTerminationReason(executionTimeout.timeoutKind)\n          : executionSignal.aborted\n            ? \"client-abort\"\n            : \"provider-error\",\n      );\n      executionTimeout.dispose();\n      releaseRequestSlot();\n      return Response.json(\n        {\n          error: executionTimeout.timeoutKind\n            ? getSurveyAssistantExecutionTimeoutMessage(executionTimeout.timeoutKind)\n            : handleStreamError(error),\n        },\n        { status: 503 },\n      );\n    }\n\n    const turnStream = createSurveyAssistantTurnStream({\n      stream,\n      turnDraft,\n      signal: executionSignal,\n      getAbortErrorText: () =>\n        executionTimeout.timeoutKind\n          ? getSurveyAssistantExecutionTimeoutMessage(executionTimeout.timeoutKind)\n          : undefined,\n      getAbortTerminationReason: () =>\n        executionTimeout.timeoutKind\n          ? getTimeoutTerminationReason(executionTimeout.timeoutKind)\n          : request.signal.aborted\n            ? \"client-abort\"\n            : undefined,\n      onActivity: executionTimeout.recordActivity,\n      onUnexpectedError: handleStreamError,\n      onSettled: () => {\n        executionTimeout.dispose();\n        releaseRequestSlot();\n        metrics.durationMs = Date.now() - executionStartedAt;\n        metrics.terminationReason = turnDraft.final?.terminationReason;\n        try {\n          options.onTurnMetrics?.({\n            identity,\n            metrics,\n            provider: modelSelection?.providerName ?? options.providerName,\n            requestId,\n            turnId: turnDraft.turnId,\n          });\n        } catch (error) {\n          try {\n            options.onStreamError?.(error, streamErrorContext);\n          } catch {\n            // Host observability hooks must not break an already-settled stream.\n          }\n        }\n      },\n      turnStartedAt: executionStartedAt,\n    });\n\n    return createUIMessageStreamResponse({ stream: turnStream });\n  };\n};\n","import {\n  createSurveyAssistantThreadInputSchema,\n  surveyEditorUITaskSchema,\n  updateSurveyAssistantThreadInputSchema,\n  type SurveyAssistantThread,\n} from \"../protocol\";\nimport { readSurveyAssistantRequestJson, SurveyAssistantRequestError } from \"./request-guardrails\";\n\nconst DEFAULT_TITLE = \"New chat\";\nconst MAX_THREAD_MUTATION_BYTES = 16 * 1024;\n// Includes the validated 64k-character task data and UTF-8/JSON encoding overhead.\nconst MAX_THREAD_CREATE_BYTES = 256 * 1024;\nconst TASK_METADATA_KEY = \"surveyAssistant.task\";\nconst MANUAL_TITLE_METADATA_KEY = \"surveyAssistant.manualTitle\";\nconst AUTOMATIC_TITLE_METADATA_KEY = \"surveyAssistant.automaticTitle\";\n\nexport interface SurveyAssistantThreadIdentity {\n  resourceId: string;\n  metadata: Record<string, string>;\n}\n\nexport interface CreateSurveyAssistantThreadHandlersOptions {\n  authorize(\n    request: Request,\n  ): SurveyAssistantThreadIdentity | Promise<SurveyAssistantThreadIdentity>;\n  onError?(error: unknown, context: SurveyAssistantThreadErrorContext): void;\n  repository: SurveyAssistantThreadRepository;\n}\n\nexport interface SurveyAssistantThreadErrorContext {\n  operation: \"create\" | \"delete\" | \"list\" | \"read\" | \"update\";\n  request: Request;\n  threadId?: string;\n}\n\nexport interface SurveyAssistantStoredThread {\n  id: string;\n  title?: string;\n  resourceId: string;\n  createdAt: Date;\n  updatedAt: Date;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface SurveyAssistantThreadRepository {\n  create(input: {\n    resourceId: string;\n    title: string;\n    metadata: Record<string, unknown>;\n  }): Promise<SurveyAssistantStoredThread>;\n  get(threadId: string): Promise<SurveyAssistantStoredThread | null>;\n  list(\n    resourceId: string,\n    metadata: Record<string, string>,\n    options?: { cursor?: string },\n  ): Promise<\n    SurveyAssistantStoredThread[] | { threads: SurveyAssistantStoredThread[]; nextCursor?: string }\n  >;\n  readMessages(\n    threadId: string,\n    resourceId: string,\n    cursor?: string,\n  ): Promise<unknown[] | { messages: unknown[]; nextCursor?: string }>;\n  delete(threadId: string): Promise<void>;\n  update(input: {\n    id: string;\n    title: string;\n    metadata: Record<string, unknown>;\n  }): Promise<SurveyAssistantStoredThread>;\n}\n\nconst getMetadataString = (metadata: Record<string, unknown> | undefined, key: string) => {\n  const value = metadata?.[key];\n  return typeof value === \"string\" && value.trim() ? value.trim() : undefined;\n};\n\nconst getRawTitle = (thread: SurveyAssistantStoredThread) => thread.title?.trim() || DEFAULT_TITLE;\n\nconst getAutomaticTitle = (thread: SurveyAssistantStoredThread, manualTitle: string): string => {\n  const rawTitle = thread.title?.trim();\n  if (rawTitle && rawTitle !== manualTitle) return rawTitle;\n  return getMetadataString(thread.metadata, AUTOMATIC_TITLE_METADATA_KEY) ?? DEFAULT_TITLE;\n};\n\nconst asThread = (\n  thread: SurveyAssistantStoredThread,\n  includeTask = true,\n): SurveyAssistantThread => {\n  const manualTitle = getMetadataString(thread.metadata, MANUAL_TITLE_METADATA_KEY);\n  const parsedTask = includeTask\n    ? surveyEditorUITaskSchema.safeParse(thread.metadata?.[TASK_METADATA_KEY])\n    : undefined;\n  const task = parsedTask?.success ? parsedTask.data : undefined;\n\n  return {\n    id: thread.id,\n    title: manualTitle ?? getRawTitle(thread),\n    titleMode: manualTitle ? \"manual\" : \"automatic\",\n    createdAt: thread.createdAt.toISOString(),\n    updatedAt: thread.updatedAt.toISOString(),\n    ...(task ? { task } : {}),\n  };\n};\n\nconst json = (body: unknown, status = 200) => Response.json(body, { status });\n\nconst errorResponse = (\n  error: unknown,\n  onError: CreateSurveyAssistantThreadHandlersOptions[\"onError\"],\n  context: SurveyAssistantThreadErrorContext,\n) => {\n  const status =\n    typeof error === \"object\" &&\n    error !== null &&\n    \"status\" in error &&\n    typeof error.status === \"number\"\n      ? error.status\n      : error instanceof SurveyAssistantRequestError ||\n          error instanceof SyntaxError ||\n          (error instanceof Error && error.name === \"ZodError\")\n        ? 400\n        : 500;\n  if (status >= 500) {\n    try {\n      if (onError) {\n        onError(error, context);\n      } else {\n        const url = new URL(context.request.url);\n        console.error(\"[survey-assistant] thread request error\", {\n          operation: context.operation,\n          method: context.request.method,\n          path: url.pathname,\n          ...(context.threadId ? { threadId: context.threadId } : {}),\n          error,\n        });\n      }\n    } catch {\n      // Error reporting must not replace the sanitized HTTP response.\n    }\n  }\n  const message =\n    error instanceof SurveyAssistantRequestError\n      ? error.message\n      : status === 401 || status === 403 || status === 404\n        ? status === 404\n          ? \"Chat not found.\"\n          : \"The chat request is not authorized.\"\n        : status >= 500\n          ? \"The chat request could not be completed.\"\n          : \"The chat request is invalid.\";\n  return json(\n    {\n      code:\n        status === 401 || status === 403 || status === 404\n          ? \"authorization_failed\"\n          : \"request_failed\",\n      error: message,\n    },\n    status,\n  );\n};\n\nconst ownsThread = (thread: SurveyAssistantStoredThread, identity: SurveyAssistantThreadIdentity) =>\n  thread.resourceId === identity.resourceId &&\n  Object.entries(identity.metadata).every(([key, value]) => thread.metadata?.[key] === value);\n\nconst getOwnedThread = async (\n  repository: SurveyAssistantThreadRepository,\n  identity: SurveyAssistantThreadIdentity,\n  threadId: string,\n) => {\n  const thread = await repository.get(threadId);\n  return thread && ownsThread(thread, identity) ? thread : null;\n};\n\nexport const createSurveyAssistantThreadHandlers = ({\n  authorize,\n  onError,\n  repository,\n}: CreateSurveyAssistantThreadHandlersOptions) => {\n  const list = async (request: Request) => {\n    try {\n      const identity = await authorize(request);\n      const url = new URL(request.url);\n      const cursor = url.searchParams.get(\"cursor\")?.trim() || undefined;\n      const result = await repository.list(identity.resourceId, identity.metadata, {\n        ...(cursor ? { cursor } : {}),\n      });\n      const storedThreads = Array.isArray(result) ? result : result.threads;\n      const threads = storedThreads\n        .filter(\n          (thread) =>\n            ownsThread(thread, identity) && typeof thread.metadata?.archivedAt !== \"string\",\n        )\n        .map((thread) => asThread(thread, false));\n      return json({\n        threads,\n        ...(!Array.isArray(result) && result.nextCursor ? { nextCursor: result.nextCursor } : {}),\n      });\n    } catch (error) {\n      return errorResponse(error, onError, { operation: \"list\", request });\n    }\n  };\n\n  const create = async (request: Request) => {\n    try {\n      const [identity, input] = await Promise.all([\n        authorize(request),\n        readSurveyAssistantRequestJson(request, MAX_THREAD_CREATE_BYTES),\n      ]);\n      const parsed = createSurveyAssistantThreadInputSchema.parse(input);\n      const metadata: Record<string, unknown> = { ...identity.metadata };\n      if (parsed.task) metadata[TASK_METADATA_KEY] = parsed.task;\n      if (parsed.title) {\n        metadata[MANUAL_TITLE_METADATA_KEY] = parsed.title;\n        metadata[AUTOMATIC_TITLE_METADATA_KEY] = DEFAULT_TITLE;\n      }\n      const thread = await repository.create({\n        resourceId: identity.resourceId,\n        title: parsed.title ?? DEFAULT_TITLE,\n        metadata,\n      });\n      return json({ thread: asThread(thread) }, 201);\n    } catch (error) {\n      return errorResponse(error, onError, { operation: \"create\", request });\n    }\n  };\n\n  const read = async (request: Request, threadId: string) => {\n    try {\n      const identity = await authorize(request);\n      const thread = await getOwnedThread(repository, identity, threadId);\n      if (!thread || typeof thread.metadata?.archivedAt === \"string\") {\n        return json({ error: \"Chat not found.\" }, 404);\n      }\n      const cursor = new URL(request.url).searchParams.get(\"cursor\")?.trim() || undefined;\n      const result = await repository.readMessages(threadId, identity.resourceId, cursor);\n      return json({\n        thread: asThread(thread),\n        messages: Array.isArray(result) ? result : result.messages,\n        ...(!Array.isArray(result) && result.nextCursor ? { nextCursor: result.nextCursor } : {}),\n      });\n    } catch (error) {\n      return errorResponse(error, onError, { operation: \"read\", request, threadId });\n    }\n  };\n\n  const update = async (request: Request, threadId: string) => {\n    try {\n      const [identity, input] = await Promise.all([\n        authorize(request),\n        readSurveyAssistantRequestJson(request, MAX_THREAD_MUTATION_BYTES),\n      ]);\n      const thread = await getOwnedThread(repository, identity, threadId);\n      if (!thread || typeof thread.metadata?.archivedAt === \"string\") {\n        return json({ error: \"Chat not found.\" }, 404);\n      }\n      const parsed = updateSurveyAssistantThreadInputSchema.parse(input);\n      const metadata = { ...(thread.metadata ?? identity.metadata) };\n      let title: string;\n\n      if (parsed.mode === \"automatic\") {\n        const manualTitle = getMetadataString(metadata, MANUAL_TITLE_METADATA_KEY);\n        title =\n          parsed.title ??\n          (manualTitle ? getAutomaticTitle(thread, manualTitle) : getRawTitle(thread));\n        metadata[MANUAL_TITLE_METADATA_KEY] = null;\n        metadata[AUTOMATIC_TITLE_METADATA_KEY] = null;\n      } else {\n        const previousManualTitle = getMetadataString(metadata, MANUAL_TITLE_METADATA_KEY);\n        const automaticTitle = previousManualTitle\n          ? getAutomaticTitle(thread, previousManualTitle)\n          : getRawTitle(thread);\n        title = parsed.title;\n        metadata[MANUAL_TITLE_METADATA_KEY] = title;\n        metadata[AUTOMATIC_TITLE_METADATA_KEY] = automaticTitle;\n      }\n\n      const updated = await repository.update({\n        id: thread.id,\n        title,\n        metadata,\n      });\n      return json({ thread: asThread(updated) });\n    } catch (error) {\n      return errorResponse(error, onError, { operation: \"update\", request, threadId });\n    }\n  };\n\n  const deleteThread = async (request: Request, threadId: string) => {\n    try {\n      const identity = await authorize(request);\n      const thread = await getOwnedThread(repository, identity, threadId);\n      if (!thread) return json({ error: \"Chat not found.\" }, 404);\n      await repository.delete(thread.id);\n      return new Response(null, { status: 204 });\n    } catch (error) {\n      return errorResponse(error, onError, { operation: \"delete\", request, threadId });\n    }\n  };\n\n  return { create, delete: deleteThread, list, read, update };\n};\n","import { toAISdkMessages } from \"@mastra/ai-sdk/ui\";\nimport type { MastraMemory } from \"@mastra/core/memory\";\nimport type { SurveyAssistantThreadDocumentRepository } from \"./thread-documents\";\nimport type { SurveyAssistantThreadRepository } from \"./thread-handlers\";\n\ntype ThreadMemory = Pick<\n  MastraMemory,\n  \"createThread\" | \"deleteThread\" | \"getThreadById\" | \"listThreads\" | \"recall\" | \"updateThread\"\n>;\n\nexport interface CreateMastraMemoryThreadRepositoryOptions {\n  getMemory(): ThreadMemory | Promise<ThreadMemory>;\n  /** Maximum recent messages returned per transcript page. */\n  maxMessagesPerTranscript?: number;\n  /** Maximum threads returned per history page. */\n  maxThreadsPerList?: number;\n  threadDocuments?: SurveyAssistantThreadDocumentRepository;\n}\n\nexport const createMastraMemoryThreadRepository = ({\n  getMemory,\n  maxMessagesPerTranscript = 100,\n  maxThreadsPerList = 30,\n  threadDocuments,\n}: CreateMastraMemoryThreadRepositoryOptions): SurveyAssistantThreadRepository => ({\n  async create({ metadata, resourceId, title }) {\n    return (await getMemory()).createThread({ metadata, resourceId, title, saveThread: true });\n  },\n  async get(threadId) {\n    return (await getMemory()).getThreadById({ threadId });\n  },\n  async list(resourceId, metadata, options) {\n    const page = Number.parseInt(options?.cursor ?? \"0\", 10);\n    const perPage = Math.max(1, Math.min(200, maxThreadsPerList));\n    const result = await (\n      await getMemory()\n    ).listThreads({\n      filter: { metadata, resourceId },\n      orderBy: { field: \"updatedAt\", direction: \"DESC\" },\n      page: Number.isFinite(page) && page >= 0 ? page : 0,\n      perPage,\n    });\n    return {\n      ...(result.hasMore ? { nextCursor: String(result.page + 1) } : {}),\n      threads: result.threads,\n    };\n  },\n  async readMessages(threadId, resourceId, cursor) {\n    const page = Number.parseInt(cursor ?? \"0\", 10);\n    const result = await (\n      await getMemory()\n    ).recall({\n      threadId,\n      resourceId,\n      page: Number.isFinite(page) && page >= 0 ? page : 0,\n      perPage: Math.max(1, Math.min(5_000, maxMessagesPerTranscript)),\n      orderBy: { field: \"createdAt\", direction: \"DESC\" },\n    });\n    return {\n      messages: toAISdkMessages([...result.messages].reverse(), { version: \"v6\" }),\n      ...(result.hasMore ? { nextCursor: String(result.page + 1) } : {}),\n    };\n  },\n  async delete(threadId) {\n    const memory = await getMemory();\n    const thread = await memory.getThreadById({ threadId });\n    if (thread && threadDocuments) {\n      await threadDocuments.deleteThread({ resourceId: thread.resourceId, threadId });\n    }\n    await memory.deleteThread(threadId);\n  },\n  async update({ id, metadata, title }) {\n    return (await getMemory()).updateThread({ id, metadata, title });\n  },\n});\n"],"mappings":"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"}