serve-sim 0.0.0

package/dist/middleware.cjs

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./middleware.js");

package/dist/middleware.js

@@ -0,0 +1,7 @@
+// @bun
+import{readdirSync as J,readFileSync as P}from"fs";import{spawn as j}from"child_process";import{tmpdir as k}from"os";import{join as H}from"path";var F=H(k(),"serve-sim");function Z(){let U;try{U=J(F).filter((G)=>G.startsWith("server-")&&G.endsWith(".json"))}catch{return[]}let B=[];for(let G of U)try{let z=JSON.parse(P(H(F,G),"utf-8"));try{process.kill(z.pid,0),B.push(z)}catch{}}catch{}return B}var $=null;function D(){if(!$)$=Buffer.from("<!doctype html>
<html><head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Simulator Preview</title>
<style>*,*::before,*::after{box-sizing:border-box}html,body{margin:0;height:100%;overflow:hidden}</style>
</head><body>
<div id="root"></div>
<!--__SIM_PREVIEW_CONFIG__-->
<script type="module">var b0,P,b4,j5,K0,w4,p4,v4,X4,C0,U0,j4,K4,Y4,Z4,R4,w0={},S0=[],R5=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,A0=Array.isArray;function X0(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function Q4(X){X&&X.parentNode&&X.parentNode.removeChild(X)}function Y0(X,Y,Z){var J,q,K,Q={};for(K in Y)K=="key"?J=Y[K]:K=="ref"?q=Y[K]:Q[K]=Y[K];if(arguments.length>2&&(Q.children=arguments.length>3?b0.call(arguments,2):Z),typeof X=="function"&&X.defaultProps!=null)for(K in X.defaultProps)Q[K]===void 0&&(Q[K]=X.defaultProps[K]);return E0(X,Q,J,q,null)}function E0(X,Y,Z,J,q){var K={type:X,props:Y,key:Z,ref:J,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:q==null?++b4:q,__i:-1,__u:0};return q==null&&P.vnode!=null&&P.vnode(K),K}function x(X){return X.children}function g(X,Y){this.props=X,this.context=Y}function L0(X,Y){if(Y==null)return X.__?L0(X.__,X.__i+1):null;for(var Z;Y<X.__k.length;Y++)if((Z=X.__k[Y])!=null&&Z.__e!=null)return Z.__e;return typeof X.type=="function"?L0(X):null}function y5(X){if(X.__P&&X.__d){var Y=X.__v,Z=Y.__e,J=[],q=[],K=X0({},Y);K.__v=Y.__v+1,P.vnode&&P.vnode(K),$4(X.__P,K,Y,X.__n,X.__P.namespaceURI,32&Y.__u?[Z]:null,J,Z==null?L0(Y):Z,!!(32&Y.__u),q),K.__v=Y.__v,K.__.__k[K.__i]=K,d4(J,K,q),Y.__e=Y.__=null,K.__e!=Z&&y4(K)}}function y4(X){if((X=X.__)!=null&&X.__c!=null)return X.__e=X.__c.base=null,X.__k.some(function(Y){if(Y!=null&&Y.__e!=null)return X.__e=X.__c.base=Y.__e}),y4(X)}function J4(X){(!X.__d&&(X.__d=!0)&&K0.push(X)&&!T0.__r++||w4!=P.debounceRendering)&&((w4=P.debounceRendering)||p4)(T0)}function T0(){try{for(var X,Y=1;K0.length;)K0.length>Y&&K0.sort(v4),X=K0.shift(),Y=K0.length,y5(X)}finally{K0.length=T0.__r=0}}function g4(X,Y,Z,J,q,K,Q,z,G,L,D){var W,O,U,k,_,C,M,F=J&&J.__k||S0,E=Y.length;for(G=g5(Z,Y,F,G,E),W=0;W<E;W++)(U=Z.__k[W])!=null&&(O=U.__i!=-1&&F[U.__i]||w0,U.__i=W,C=$4(X,U,O,q,K,Q,z,G,L,D),k=U.__e,U.ref&&O.ref!=U.ref&&(O.ref&&W4(O.ref,null,U),D.push(U.ref,U.__c||k,U)),_==null&&k!=null&&(_=k),(M=!!(4&U.__u))||O.__k===U.__k?(G=x4(U,G,X,M),M&&O.__e&&(O.__e=null)):typeof U.type=="function"&&C!==void 0?G=C:k&&(G=k.nextSibling),U.__u&=-7);return Z.__e=_,G}function g5(X,Y,Z,J,q){var K,Q,z,G,L,D=Z.length,W=D,O=0;for(X.__k=Array(q),K=0;K<q;K++)(Q=Y[K])!=null&&typeof Q!="boolean"&&typeof Q!="function"?(typeof Q=="string"||typeof Q=="number"||typeof Q=="bigint"||Q.constructor==String?Q=X.__k[K]=E0(null,Q,null,null,null):A0(Q)?Q=X.__k[K]=E0(x,{children:Q},null,null,null):Q.constructor===void 0&&Q.__b>0?Q=X.__k[K]=E0(Q.type,Q.props,Q.key,Q.ref?Q.ref:null,Q.__v):X.__k[K]=Q,G=K+O,Q.__=X,Q.__b=X.__b+1,z=null,(L=Q.__i=x5(Q,Z,G,W))!=-1&&(W--,(z=Z[L])&&(z.__u|=2)),z==null||z.__v==null?(L==-1&&(q>D?O--:q<D&&O++),typeof Q.type!="function"&&(Q.__u|=4)):L!=G&&(L==G-1?O--:L==G+1?O++:(L>G?O--:O++,Q.__u|=4))):X.__k[K]=null;if(W)for(K=0;K<D;K++)(z=Z[K])!=null&&(2&z.__u)==0&&(z.__e==J&&(J=L0(z)),h4(z,z));return J}function x4(X,Y,Z,J){var q,K;if(typeof X.type=="function"){for(q=X.__k,K=0;q&&K<q.length;K++)q[K]&&(q[K].__=X,Y=x4(q[K],Y,Z,J));return Y}X.__e!=Y&&(J&&(Y&&X.type&&!Y.parentNode&&(Y=L0(X)),Z.insertBefore(X.__e,Y||null)),Y=X.__e);do Y=Y&&Y.nextSibling;while(Y!=null&&Y.nodeType==8);return Y}function Z0(X,Y){return Y=Y||[],X==null||typeof X=="boolean"||(A0(X)?X.some(function(Z){Z0(Z,Y)}):Y.push(X)),Y}function x5(X,Y,Z,J){var q,K,Q,z=X.key,G=X.type,L=Y[Z],D=L!=null&&(2&L.__u)==0;if(L===null&&z==null||D&&z==L.key&&G==L.type)return Z;if(J>(D?1:0)){for(q=Z-1,K=Z+1;q>=0||K<Y.length;)if((L=Y[Q=q>=0?q--:K++])!=null&&(2&L.__u)==0&&z==L.key&&G==L.type)return Q}return-1}function S4(X,Y,Z){Y[0]=="-"?X.setProperty(Y,Z==null?"":Z):X[Y]=Z==null?"":typeof Z!="number"||R5.test(Y)?Z:Z+"px"}function M0(X,Y,Z,J,q){var K,Q;X:if(Y=="style")if(typeof Z=="string")X.style.cssText=Z;else{if(typeof J=="string"&&(X.style.cssText=J=""),J)for(Y in J)Z&&Y in Z||S4(X.style,Y,"");if(Z)for(Y in Z)J&&Z[Y]==J[Y]||S4(X.style,Y,Z[Y])}else if(Y[0]=="o"&&Y[1]=="n")K=Y!=(Y=Y.replace(j4,"$1")),Q=Y.toLowerCase(),Y=Q in X||Y=="onFocusOut"||Y=="onFocusIn"?Q.slice(2):Y.slice(2),X.l||(X.l={}),X.l[Y+K]=Z,Z?J?Z[U0]=J[U0]:(Z[U0]=K4,X.addEventListener(Y,K?Z4:Y4,K)):X.removeEventListener(Y,K?Z4:Y4,K);else{if(q=="http://www.w3.org/2000/svg")Y=Y.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(Y!="width"&&Y!="height"&&Y!="href"&&Y!="list"&&Y!="form"&&Y!="tabIndex"&&Y!="download"&&Y!="rowSpan"&&Y!="colSpan"&&Y!="role"&&Y!="popover"&&Y in X)try{X[Y]=Z==null?"":Z;break X}catch(z){}typeof Z=="function"||(Z==null||Z===!1&&Y[4]!="-"?X.removeAttribute(Y):X.setAttribute(Y,Y=="popover"&&Z==1?"":Z))}}function T4(X){return function(Y){if(this.l){var Z=this.l[Y.type+X];if(Y[C0]==null)Y[C0]=K4++;else if(Y[C0]<Z[U0])return;return Z(P.event?P.event(Y):Y)}}}function $4(X,Y,Z,J,q,K,Q,z,G,L){var D,W,O,U,k,_,C,M,F,E,I,v,r,f,i,y=Y.type;if(Y.constructor!==void 0)return null;128&Z.__u&&(G=!!(32&Z.__u),K=[z=Y.__e=Z.__e]),(D=P.__b)&&D(Y);X:if(typeof y=="function")try{if(M=Y.props,F=y.prototype&&y.prototype.render,E=(D=y.contextType)&&J[D.__c],I=D?E?E.props.value:D.__:J,Z.__c?C=(W=Y.__c=Z.__c).__=W.__E:(F?Y.__c=W=new y(M,I):(Y.__c=W=new g(M,I),W.constructor=y,W.render=m5),E&&E.sub(W),W.state||(W.state={}),W.__n=J,O=W.__d=!0,W.__h=[],W._sb=[]),F&&W.__s==null&&(W.__s=W.state),F&&y.getDerivedStateFromProps!=null&&(W.__s==W.state&&(W.__s=X0({},W.__s)),X0(W.__s,y.getDerivedStateFromProps(M,W.__s))),U=W.props,k=W.state,W.__v=Y,O)F&&y.getDerivedStateFromProps==null&&W.componentWillMount!=null&&W.componentWillMount(),F&&W.componentDidMount!=null&&W.__h.push(W.componentDidMount);else{if(F&&y.getDerivedStateFromProps==null&&M!==U&&W.componentWillReceiveProps!=null&&W.componentWillReceiveProps(M,I),Y.__v==Z.__v||!W.__e&&W.shouldComponentUpdate!=null&&W.shouldComponentUpdate(M,W.__s,I)===!1){Y.__v!=Z.__v&&(W.props=M,W.state=W.__s,W.__d=!1),Y.__e=Z.__e,Y.__k=Z.__k,Y.__k.some(function(m){m&&(m.__=Y)}),S0.push.apply(W.__h,W._sb),W._sb=[],W.__h.length&&Q.push(W);break X}W.componentWillUpdate!=null&&W.componentWillUpdate(M,W.__s,I),F&&W.componentDidUpdate!=null&&W.__h.push(function(){W.componentDidUpdate(U,k,_)})}if(W.context=I,W.props=M,W.__P=X,W.__e=!1,v=P.__r,r=0,F)W.state=W.__s,W.__d=!1,v&&v(Y),D=W.render(W.props,W.state,W.context),S0.push.apply(W.__h,W._sb),W._sb=[];else do W.__d=!1,v&&v(Y),D=W.render(W.props,W.state,W.context),W.state=W.__s;while(W.__d&&++r<25);W.state=W.__s,W.getChildContext!=null&&(J=X0(X0({},J),W.getChildContext())),F&&!O&&W.getSnapshotBeforeUpdate!=null&&(_=W.getSnapshotBeforeUpdate(U,k)),f=D!=null&&D.type===x&&D.key==null?m4(D.props.children):D,z=g4(X,A0(f)?f:[f],Y,Z,J,q,K,Q,z,G,L),W.base=Y.__e,Y.__u&=-161,W.__h.length&&Q.push(W),C&&(W.__E=W.__=null)}catch(m){if(Y.__v=null,G||K!=null)if(m.then){for(Y.__u|=G?160:128;z&&z.nodeType==8&&z.nextSibling;)z=z.nextSibling;K[K.indexOf(z)]=null,Y.__e=z}else{for(i=K.length;i--;)Q4(K[i]);q4(Y)}else Y.__e=Z.__e,Y.__k=Z.__k,m.then||q4(Y);P.__e(m,Y,Z)}else K==null&&Y.__v==Z.__v?(Y.__k=Z.__k,Y.__e=Z.__e):z=Y.__e=d5(Z.__e,Y,Z,J,q,K,Q,G,L);return(D=P.diffed)&&D(Y),128&Y.__u?void 0:z}function q4(X){X&&(X.__c&&(X.__c.__e=!0),X.__k&&X.__k.some(q4))}function d4(X,Y,Z){for(var J=0;J<Z.length;J++)W4(Z[J],Z[++J],Z[++J]);P.__c&&P.__c(Y,X),X.some(function(q){try{X=q.__h,q.__h=[],X.some(function(K){K.call(q)})}catch(K){P.__e(K,q.__v)}})}function m4(X){return typeof X!="object"||X==null||X.__b>0?X:A0(X)?X.map(m4):X0({},X)}function d5(X,Y,Z,J,q,K,Q,z,G){var L,D,W,O,U,k,_,C=Z.props||w0,M=Y.props,F=Y.type;if(F=="svg"?q="http://www.w3.org/2000/svg":F=="math"?q="http://www.w3.org/1998/Math/MathML":q||(q="http://www.w3.org/1999/xhtml"),K!=null){for(L=0;L<K.length;L++)if((U=K[L])&&"setAttribute"in U==!!F&&(F?U.localName==F:U.nodeType==3)){X=U,K[L]=null;break}}if(X==null){if(F==null)return document.createTextNode(M);X=document.createElementNS(q,F,M.is&&M),z&&(P.__m&&P.__m(Y,K),z=!1),K=null}if(F==null)C===M||z&&X.data==M||(X.data=M);else{if(K=K&&b0.call(X.childNodes),!z&&K!=null)for(C={},L=0;L<X.attributes.length;L++)C[(U=X.attributes[L]).name]=U.value;for(L in C)U=C[L],L=="dangerouslySetInnerHTML"?W=U:L=="children"||(L in M)||L=="value"&&("defaultValue"in M)||L=="checked"&&("defaultChecked"in M)||M0(X,L,null,U,q);for(L in M)U=M[L],L=="children"?O=U:L=="dangerouslySetInnerHTML"?D=U:L=="value"?k=U:L=="checked"?_=U:z&&typeof U!="function"||C[L]===U||M0(X,L,U,C[L],q);if(D)z||W&&(D.__html==W.__html||D.__html==X.innerHTML)||(X.innerHTML=D.__html),Y.__k=[];else if(W&&(X.innerHTML=""),g4(Y.type=="template"?X.content:X,A0(O)?O:[O],Y,Z,J,F=="foreignObject"?"http://www.w3.org/1999/xhtml":q,K,Q,K?K[0]:Z.__k&&L0(Z,0),z,G),K!=null)for(L=K.length;L--;)Q4(K[L]);z||(L="value",F=="progress"&&k==null?X.removeAttribute("value"):k!=null&&(k!==X[L]||F=="progress"&&!k||F=="option"&&k!=C[L])&&M0(X,L,k,C[L],q),L="checked",_!=null&&_!=X[L]&&M0(X,L,_,C[L],q))}return X}function W4(X,Y,Z){try{if(typeof X=="function"){var J=typeof X.__u=="function";J&&X.__u(),J&&Y==null||(X.__u=X(Y))}else X.current=Y}catch(q){P.__e(q,Z)}}function h4(X,Y,Z){var J,q;if(P.unmount&&P.unmount(X),(J=X.ref)&&(J.current&&J.current!=X.__e||W4(J,null,Y)),(J=X.__c)!=null){if(J.componentWillUnmount)try{J.componentWillUnmount()}catch(K){P.__e(K,Y)}J.base=J.__P=null}if(J=X.__k)for(q=0;q<J.length;q++)J[q]&&h4(J[q],Y,Z||typeof X.type!="function");Z||Q4(X.__e),X.__c=X.__=X.__e=void 0}function m5(X,Y,Z){return this.constructor(X,Z)}function p0(X,Y,Z){var J,q,K,Q;Y==document&&(Y=document.documentElement),P.__&&P.__(X,Y),q=(J=typeof Z=="function")?null:Z&&Z.__k||Y.__k,K=[],Q=[],$4(Y,X=(!J&&Z||Y).__k=Y0(x,null,[X]),q||w0,w0,Y.namespaceURI,!J&&Z?[Z]:q?null:Y.firstChild?b0.call(Y.childNodes):null,K,!J&&Z?Z:q?q.__e:Y.firstChild,J,Q),d4(K,X,Q)}function z0(X){function Y(Z){var J,q;return this.getChildContext||(J=new Set,(q={})[Y.__c]=this,this.getChildContext=function(){return q},this.componentWillUnmount=function(){J=null},this.shouldComponentUpdate=function(K){this.props.value!=K.value&&J.forEach(function(Q){Q.__e=!0,J4(Q)})},this.sub=function(K){J.add(K);var Q=K.componentWillUnmount;K.componentWillUnmount=function(){J&&J.delete(K),Q&&Q.call(K)}}),Z.children}return Y.__c="__cC"+R4++,Y.__=X,Y.Provider=Y.__l=(Y.Consumer=function(Z,J){return Z.children(J)}).contextType=Y,Y}b0=S0.slice,P={__e:function(X,Y,Z,J){for(var q,K,Q;Y=Y.__;)if((q=Y.__c)&&!q.__)try{if((K=q.constructor)&&K.getDerivedStateFromError!=null&&(q.setState(K.getDerivedStateFromError(X)),Q=q.__d),q.componentDidCatch!=null&&(q.componentDidCatch(X,J||{}),Q=q.__d),Q)return q.__E=q}catch(z){X=z}throw X}},b4=0,j5=function(X){return X!=null&&X.constructor===void 0},g.prototype.setState=function(X,Y){var Z;Z=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=X0({},this.state),typeof X=="function"&&(X=X(X0({},Z),this.props)),X&&X0(Z,X),X!=null&&this.__v&&(Y&&this._sb.push(Y),J4(this))},g.prototype.forceUpdate=function(X){this.__v&&(this.__e=!0,X&&this.__h.push(X),J4(this))},g.prototype.render=x,K0=[],p4=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,v4=function(X,Y){return X.__v.__b-Y.__v.__b},T0.__r=0,X4=Math.random().toString(8),C0="__d"+X4,U0="__a"+X4,j4=/(PointerCapture)$|Capture$/i,K4=0,Y4=T4(!1),Z4=T4(!0),R4=0;var N0,T,L4,f4,D0=0,r4=[],b=P,a4=b.__b,c4=b.__r,l4=b.diffed,i4=b.__c,s4=b.unmount,o4=b.__;function j0(X,Y){b.__h&&b.__h(T,X,D0||Y),D0=0;var Z=T.__H||(T.__H={__:[],__h:[]});return X>=Z.__.length&&Z.__.push({}),Z.__[X]}function p(X){return D0=1,N4(n4,X)}function N4(X,Y,Z){var J=j0(N0++,2);if(J.t=X,!J.__c&&(J.__=[Z?Z(Y):n4(void 0,Y),function(z){var G=J.__N?J.__N[0]:J.__[0],L=J.t(G,z);G!==L&&(J.__N=[L,J.__[1]],J.__c.setState({}))}],J.__c=T,!T.__f)){var q=function(z,G,L){if(!J.__c.__H)return!0;var D=J.__c.__H.__.filter(function(O){return O.__c});if(D.every(function(O){return!O.__N}))return!K||K.call(this,z,G,L);var W=J.__c.props!==z;return D.some(function(O){if(O.__N){var U=O.__[0];O.__=O.__N,O.__N=void 0,U!==O.__[0]&&(W=!0)}}),K&&K.call(this,z,G,L)||W};T.__f=!0;var{shouldComponentUpdate:K,componentWillUpdate:Q}=T;T.componentWillUpdate=function(z,G,L){if(this.__e){var D=K;K=void 0,q(z,G,L),K=D}Q&&Q.call(this,z,G,L)},T.shouldComponentUpdate=q}return J.__N||J.__}function d(X,Y){var Z=j0(N0++,3);!b.__s&&t4(Z.__H,Y)&&(Z.__=X,Z.u=Y,T.__H.__h.push(Z))}function w(X){return D0=5,R0(function(){return{current:X}},[])}function R0(X,Y){var Z=j0(N0++,7);return t4(Z.__H,Y)&&(Z.__=X(),Z.__H=Y,Z.__h=X),Z.__}function j(X,Y){return D0=8,R0(function(){return X},Y)}function P0(X){var Y=T.context[X.__c],Z=j0(N0++,9);return Z.c=X,Y?(Z.__==null&&(Z.__=!0,Y.sub(T)),Y.props.value):X.__}function h5(){for(var X;X=r4.shift();){var Y=X.__H;if(X.__P&&Y)try{Y.__h.some(v0),Y.__h.some(z4),Y.__h=[]}catch(Z){Y.__h=[],b.__e(Z,X.__v)}}}b.__b=function(X){T=null,a4&&a4(X)},b.__=function(X,Y){X&&Y.__k&&Y.__k.__m&&(X.__m=Y.__k.__m),o4&&o4(X,Y)},b.__r=function(X){c4&&c4(X),N0=0;var Y=(T=X.__c).__H;Y&&(L4===T?(Y.__h=[],T.__h=[],Y.__.some(function(Z){Z.__N&&(Z.__=Z.__N),Z.u=Z.__N=void 0})):(Y.__h.some(v0),Y.__h.some(z4),Y.__h=[],N0=0)),L4=T},b.diffed=function(X){l4&&l4(X);var Y=X.__c;Y&&Y.__H&&(Y.__H.__h.length&&(r4.push(Y)!==1&&f4===b.requestAnimationFrame||((f4=b.requestAnimationFrame)||f5)(h5)),Y.__H.__.some(function(Z){Z.u&&(Z.__H=Z.u),Z.u=void 0})),L4=T=null},b.__c=function(X,Y){Y.some(function(Z){try{Z.__h.some(v0),Z.__h=Z.__h.filter(function(J){return!J.__||z4(J)})}catch(J){Y.some(function(q){q.__h&&(q.__h=[])}),Y=[],b.__e(J,Z.__v)}}),i4&&i4(X,Y)},b.unmount=function(X){s4&&s4(X);var Y,Z=X.__c;Z&&Z.__H&&(Z.__H.__.some(function(J){try{v0(J)}catch(q){Y=q}}),Z.__H=void 0,Y&&b.__e(Y,Z.__v))};var u4=typeof requestAnimationFrame=="function";function f5(X){var Y,Z=function(){clearTimeout(J),u4&&cancelAnimationFrame(Y),setTimeout(X)},J=setTimeout(Z,35);u4&&(Y=requestAnimationFrame(Z))}function v0(X){var Y=T,Z=X.__c;typeof Z=="function"&&(X.__c=void 0,Z()),T=Y}function z4(X){var Y=T;X.__c=X.__(),T=Y}function t4(X,Y){return!X||X.length!==Y.length||Y.some(function(Z,J){return Z!==X[J]})}function n4(X,Y){return typeof Y=="function"?Y(X):Y}function u5(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function e4(X,Y){for(var Z in X)if(Z!=="__source"&&!(Z in Y))return!0;for(var J in Y)if(J!=="__source"&&X[J]!==Y[J])return!0;return!1}function X5(X,Y){this.props=X,this.context=Y}(X5.prototype=new g).isPureReactComponent=!0,X5.prototype.shouldComponentUpdate=function(X,Y){return e4(this.props,X)||e4(this.state,Y)};var Y5=P.__b;P.__b=function(X){X.type&&X.type.__f&&X.ref&&(X.props.ref=X.ref,X.ref=null),Y5&&Y5(X)};var r5=P.__e;P.__e=function(X,Y,Z,J){if(X.then){for(var q,K=Y;K=K.__;)if((q=K.__c)&&q.__c)return Y.__e==null&&(Y.__e=Z.__e,Y.__k=Z.__k),q.__c(X,Y)}r5(X,Y,Z,J)};var Z5=P.unmount;function W5(X,Y,Z){return X&&(X.__c&&X.__c.__H&&(X.__c.__H.__.forEach(function(J){typeof J.__c=="function"&&J.__c()}),X.__c.__H=null),(X=u5({},X)).__c!=null&&(X.__c.__P===Z&&(X.__c.__P=Y),X.__c.__e=!0,X.__c=null),X.__k=X.__k&&X.__k.map(function(J){return W5(J,Y,Z)})),X}function L5(X,Y,Z){return X&&Z&&(X.__v=null,X.__k=X.__k&&X.__k.map(function(J){return L5(J,Y,Z)}),X.__c&&X.__c.__P===Y&&(X.__e&&Z.appendChild(X.__e),X.__c.__e=!0,X.__c.__P=Z)),X}function G4(){this.__u=0,this.o=null,this.__b=null}function z5(X){var Y=X.__&&X.__.__c;return Y&&Y.__a&&Y.__a(X)}function y0(){this.i=null,this.l=null}P.unmount=function(X){var Y=X.__c;Y&&(Y.__z=!0),Y&&Y.__R&&Y.__R(),Y&&32&X.__u&&(X.type=null),Z5&&Z5(X)},(G4.prototype=new g).__c=function(X,Y){var Z=Y.__c,J=this;J.o==null&&(J.o=[]),J.o.push(Z);var q=z5(J.__v),K=!1,Q=function(){K||J.__z||(K=!0,Z.__R=null,q?q(G):G())};Z.__R=Q;var z=Z.__P;Z.__P=null;var G=function(){if(!--J.__u){if(J.state.__a){var L=J.state.__a;J.__v.__k[0]=L5(L,L.__c.__P,L.__c.__O)}var D;for(J.setState({__a:J.__b=null});D=J.o.pop();)D.__P=z,D.forceUpdate()}};J.__u++||32&Y.__u||J.setState({__a:J.__b=J.__v.__k[0]}),X.then(Q,Q)},G4.prototype.componentWillUnmount=function(){this.o=[]},G4.prototype.render=function(X,Y){if(this.__b){if(this.__v.__k){var Z=document.createElement("div"),J=this.__v.__k[0].__c;this.__v.__k[0]=W5(this.__b,Z,J.__O=J.__P)}this.__b=null}var q=Y.__a&&Y0(x,null,X.fallback);return q&&(q.__u&=-33),[Y0(x,null,Y.__a?null:X.children),q]};var J5=function(X,Y,Z){if(++Z[1]===Z[0]&&X.l.delete(Y),X.props.revealOrder&&(X.props.revealOrder[0]!=="t"||!X.l.size))for(Z=X.i;Z;){for(;Z.length>3;)Z.pop()();if(Z[1]<Z[0])break;X.i=Z=Z[2]}};(y0.prototype=new g).__a=function(X){var Y=this,Z=z5(Y.__v),J=Y.l.get(X);return J[0]++,function(q){var K=function(){Y.props.revealOrder?(J.push(q),J5(Y,X,J)):q()};Z?Z(K):K()}},y0.prototype.render=function(X){this.i=null,this.l=new Map;var Y=Z0(X.children);X.revealOrder&&X.revealOrder[0]==="b"&&Y.reverse();for(var Z=Y.length;Z--;)this.l.set(Y[Z],this.i=[1,0,this.i]);return X.children},y0.prototype.componentDidUpdate=y0.prototype.componentDidMount=function(){var X=this;this.l.forEach(function(Y,Z){J5(X,Z,Y)})};var t5=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,n5=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,e5=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,X6=/[A-Z0-9]/g,Y6=typeof document<"u",Z6=function(X){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(X)};function N5(X,Y,Z){return Y.__k==null&&(Y.textContent=""),p0(X,Y),typeof Z=="function"&&Z(),X?X.__c:null}g.prototype.isReactComponent=!0,["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(X){Object.defineProperty(g.prototype,X,{configurable:!0,get:function(){return this["UNSAFE_"+X]},set:function(Y){Object.defineProperty(this,X,{configurable:!0,writable:!0,value:Y})}})});var q5=P.event;P.event=function(X){return q5&&(X=q5(X)),X.persist=function(){},X.isPropagationStopped=function(){return this.cancelBubble},X.isDefaultPrevented=function(){return this.defaultPrevented},X.nativeEvent=X};var G5,J6={configurable:!0,get:function(){return this.class}},K5=P.vnode;P.vnode=function(X){typeof X.type=="string"&&function(Y){var{props:Z,type:J}=Y,q={},K=J.indexOf("-")==-1;for(var Q in Z){var z=Z[Q];if(!(Q==="value"&&("defaultValue"in Z)&&z==null||Y6&&Q==="children"&&J==="noscript"||Q==="class"||Q==="className")){var G=Q.toLowerCase();Q==="defaultValue"&&"value"in Z&&Z.value==null?Q="value":Q==="download"&&z===!0?z="":G==="translate"&&z==="no"?z=!1:G[0]==="o"&&G[1]==="n"?G==="ondoubleclick"?Q="ondblclick":G!=="onchange"||J!=="input"&&J!=="textarea"||Z6(Z.type)?G==="onfocus"?Q="onfocusin":G==="onblur"?Q="onfocusout":e5.test(Q)&&(Q=G):G=Q="oninput":K&&n5.test(Q)?Q=Q.replace(X6,"-$&").toLowerCase():z===null&&(z=void 0),G==="oninput"&&q[Q=G]&&(Q="oninputCapture"),q[Q]=z}}J=="select"&&(q.multiple&&Array.isArray(q.value)&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.value.indexOf(L.props.value)!=-1})),q.defaultValue!=null&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.multiple?q.defaultValue.indexOf(L.props.value)!=-1:q.defaultValue==L.props.value}))),Z.class&&!Z.className?(q.class=Z.class,Object.defineProperty(q,"className",J6)):Z.className&&(q.class=q.className=Z.className),Y.props=q}(X),X.$$typeof=t5,K5&&K5(X)};var Q5=P.__r;P.__r=function(X){Q5&&Q5(X),G5=X.__c};var $5=P.diffed;P.diffed=function(X){$5&&$5(X);var{props:Y,__e:Z}=X;Z!=null&&X.type==="textarea"&&"value"in Y&&Y.value!==Z.value&&(Z.value=Y.value==null?"":Y.value),G5=null};function V5(X){return!!X.__k&&(p0(null,X),!0)}function H5(X){return{render:function(Y){N5(Y,X)},unmount:function(){V5(X)}}}function I5(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function O5(X,Y){for(var Z in X)if(Z!=="__source"&&!(Z in Y))return!0;for(var J in Y)if(J!=="__source"&&X[J]!==Y[J])return!0;return!1}function U5(X,Y){this.props=X,this.context=Y}(U5.prototype=new g).isPureReactComponent=!0,U5.prototype.shouldComponentUpdate=function(X,Y){return O5(this.props,X)||O5(this.state,Y)};var A5=P.__b;P.__b=function(X){X.type&&X.type.__f&&X.ref&&(X.props.ref=X.ref,X.ref=null),A5&&A5(X)};var q6=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911;function G0(X){function Y(Z){var J=I5({},Z);return delete J.ref,X(J,Z.ref||null)}return Y.$$typeof=q6,Y.render=X,Y.prototype.isReactComponent=Y.__f=!0,Y.displayName="ForwardRef("+(X.displayName||X.name)+")",Y}var K6=P.__e;P.__e=function(X,Y,Z,J){if(X.then){for(var q,K=Y;K=K.__;)if((q=K.__c)&&q.__c)return Y.__e==null&&(Y.__e=Z.__e,Y.__k=Z.__k),q.__c(X,Y)}K6(X,Y,Z,J)};var D5=P.unmount;function M5(X,Y,Z){return X&&(X.__c&&X.__c.__H&&(X.__c.__H.__.forEach(function(J){typeof J.__c=="function"&&J.__c()}),X.__c.__H=null),(X=I5({},X)).__c!=null&&(X.__c.__P===Z&&(X.__c.__P=Y),X.__c.__e=!0,X.__c=null),X.__k=X.__k&&X.__k.map(function(J){return M5(J,Y,Z)})),X}function C5(X,Y,Z){return X&&Z&&(X.__v=null,X.__k=X.__k&&X.__k.map(function(J){return C5(J,Y,Z)}),X.__c&&X.__c.__P===Y&&(X.__e&&Z.appendChild(X.__e),X.__c.__e=!0,X.__c.__P=Z)),X}function H4(){this.__u=0,this.o=null,this.__b=null}function E5(X){var Y=X.__&&X.__.__c;return Y&&Y.__a&&Y.__a(X)}function g0(){this.i=null,this.l=null}P.unmount=function(X){var Y=X.__c;Y&&(Y.__z=!0),Y&&Y.__R&&Y.__R(),Y&&32&X.__u&&(X.type=null),D5&&D5(X)},(H4.prototype=new g).__c=function(X,Y){var Z=Y.__c,J=this;J.o==null&&(J.o=[]),J.o.push(Z);var q=E5(J.__v),K=!1,Q=function(){K||J.__z||(K=!0,Z.__R=null,q?q(G):G())};Z.__R=Q;var z=Z.__P;Z.__P=null;var G=function(){if(!--J.__u){if(J.state.__a){var L=J.state.__a;J.__v.__k[0]=C5(L,L.__c.__P,L.__c.__O)}var D;for(J.setState({__a:J.__b=null});D=J.o.pop();)D.__P=z,D.forceUpdate()}};J.__u++||32&Y.__u||J.setState({__a:J.__b=J.__v.__k[0]}),X.then(Q,Q)},H4.prototype.componentWillUnmount=function(){this.o=[]},H4.prototype.render=function(X,Y){if(this.__b){if(this.__v.__k){var Z=document.createElement("div"),J=this.__v.__k[0].__c;this.__v.__k[0]=M5(this.__b,Z,J.__O=J.__P)}this.__b=null}var q=Y.__a&&Y0(x,null,X.fallback);return q&&(q.__u&=-33),[Y0(x,null,Y.__a?null:X.children),q]};var P5=function(X,Y,Z){if(++Z[1]===Z[0]&&X.l.delete(Y),X.props.revealOrder&&(X.props.revealOrder[0]!=="t"||!X.l.size))for(Z=X.i;Z;){for(;Z.length>3;)Z.pop()();if(Z[1]<Z[0])break;X.i=Z=Z[2]}};(g0.prototype=new g).__a=function(X){var Y=this,Z=E5(Y.__v),J=Y.l.get(X);return J[0]++,function(q){var K=function(){Y.props.revealOrder?(J.push(q),P5(Y,X,J)):q()};Z?Z(K):K()}},g0.prototype.render=function(X){this.i=null,this.l=new Map;var Y=Z0(X.children);X.revealOrder&&X.revealOrder[0]==="b"&&Y.reverse();for(var Z=Y.length;Z--;)this.l.set(Y[Z],this.i=[1,0,this.i]);return X.children},g0.prototype.componentDidUpdate=g0.prototype.componentDidMount=function(){var X=this;this.l.forEach(function(Y,Z){P5(X,Z,Y)})};var Q6=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,$6=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,W6=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,L6=/[A-Z0-9]/g,z6=typeof document<"u",N6=function(X){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(X)};g.prototype.isReactComponent=!0,["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(X){Object.defineProperty(g.prototype,X,{configurable:!0,get:function(){return this["UNSAFE_"+X]},set:function(Y){Object.defineProperty(this,X,{configurable:!0,writable:!0,value:Y})}})});var B5=P.event;P.event=function(X){return B5&&(X=B5(X)),X.persist=function(){},X.isPropagationStopped=function(){return this.cancelBubble},X.isDefaultPrevented=function(){return this.defaultPrevented},X.nativeEvent=X};var w5,G6={configurable:!0,get:function(){return this.class}},_5=P.vnode;P.vnode=function(X){typeof X.type=="string"&&function(Y){var{props:Z,type:J}=Y,q={},K=J.indexOf("-")==-1;for(var Q in Z){var z=Z[Q];if(!(Q==="value"&&("defaultValue"in Z)&&z==null||z6&&Q==="children"&&J==="noscript"||Q==="class"||Q==="className")){var G=Q.toLowerCase();Q==="defaultValue"&&"value"in Z&&Z.value==null?Q="value":Q==="download"&&z===!0?z="":G==="translate"&&z==="no"?z=!1:G[0]==="o"&&G[1]==="n"?G==="ondoubleclick"?Q="ondblclick":G!=="onchange"||J!=="input"&&J!=="textarea"||N6(Z.type)?G==="onfocus"?Q="onfocusin":G==="onblur"?Q="onfocusout":W6.test(Q)&&(Q=G):G=Q="oninput":K&&$6.test(Q)?Q=Q.replace(L6,"-$&").toLowerCase():z===null&&(z=void 0),G==="oninput"&&q[Q=G]&&(Q="oninputCapture"),q[Q]=z}}J=="select"&&(q.multiple&&Array.isArray(q.value)&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.value.indexOf(L.props.value)!=-1})),q.defaultValue!=null&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.multiple?q.defaultValue.indexOf(L.props.value)!=-1:q.defaultValue==L.props.value}))),Z.class&&!Z.className?(q.class=Z.class,Object.defineProperty(q,"className",G6)):Z.className&&(q.class=q.className=Z.className),Y.props=q}(X),X.$$typeof=Q6,_5&&_5(X)};var F5=P.__r;P.__r=function(X){F5&&F5(X),w5=X.__c};var k5=P.diffed;P.diffed=function(X){k5&&k5(X);var{props:Y,__e:Z}=X;Z!=null&&X.type==="textarea"&&"value"in Y&&Y.value!==Z.value&&(Z.value=Y.value==null?"":Y.value),w5=null};var V6=0;function $(X,Y,Z,J,q,K){Y||(Y={});var Q,z,G=Y;if("ref"in G)for(z in G={},Y)z=="ref"?Q=Y[z]:G[z]=Y[z];var L={type:X,props:G,key:Z,ref:Q,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--V6,__i:-1,__u:0,__source:q,__self:K};if(typeof X=="function"&&(Q=X.defaultProps))for(z in Q)G[z]===void 0&&(G[z]=Q[z]);return P.vnode&&P.vnode(L),L}var O4=`url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Ccircle cx='10' cy='10' r='9' fill='rgba(255,255,255,0.4)' stroke='rgba(255,255,255,0.7)' stroke-width='1'/%3E%3C/svg%3E") 10 10, pointer`,H6=3,O6=4,U6=5;function x0({url:X,wsUrl:Y,style:Z,imageStyle:J,className:q,onHomePress:K,onStreamTouch:Q,onStreamMultiTouch:z,onStreamButton:G,subscribeFrame:L,streamFrame:D,streamConfig:W,hideControls:O,onStreamingChange:U,connectionQuality:k}){let _=!!Q,C=w(null),M=w(null),F=w(null),[E,I]=p(!1),[v,r]=p(null),[f,i]=p(null),y=w(null),[m,c0]=p(null);d(()=>{let V=y.current;if(!V||typeof ResizeObserver>"u")return;let H=new ResizeObserver((N)=>{let A=N[0]?.contentRect;if(A)c0({width:A.width,height:A.height})});return H.observe(V),()=>H.disconnect()},[]);let[D4,P4]=p(0),W0=w(0),[p5,l0]=p(!1),t=w(null);d(()=>{if(k==="poor"){if(l0(!0),t.current)clearTimeout(t.current);t.current=setTimeout(()=>{l0(!1),t.current=null},3000)}else if(l0(!1),t.current)clearTimeout(t.current),t.current=null;return()=>{if(t.current)clearTimeout(t.current)}},[k]);let i0=`${X}/stream.mjpeg`,B4=w(U);B4.current=U,d(()=>{B4.current?.(E)},[E]),d(()=>{if(_&&W)i(W)},[_,W]);let _4=w(!1);_4.current=E;let s0=w(null);d(()=>{if(!_||!L)return;return L((V)=>{W0.current++;let H=M.current;if(H){if(s0.current)URL.revokeObjectURL(s0.current);s0.current=V,H.src=V}if(!_4.current)console.log("[serve-sim] first frame received, rendering"),I(!0),r(null)})},[_,L]);let c=j((V)=>{if(_){Q?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify(V)),A=new Uint8Array(1+N.length);A[0]=H6,A.set(N,1),H.send(A)},[_,Q]),o0=j((V)=>{if(_){G?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify({button:V})),A=new Uint8Array(1+N.length);A[0]=O6,A.set(N,1),H.send(A)},[_,G]),n=j((V)=>{if(_){z?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify(V)),A=new Uint8Array(1+N.length);A[0]=U6,A.set(N,1),H.send(A)},[_,z]);d(()=>{if(_)return;fetch(`${X}/config`).then((B)=>B.json()).then((B)=>{if(B.width>0&&B.height>0)i(B)}).catch(()=>{});let V=Y??X.replace(/^http/,"ws")+"/ws",H=new WebSocket(V);H.binaryType="arraybuffer",F.current=H,H.onopen=()=>{I(!0),r(null)},H.onclose=()=>{I(!1)},H.onerror=()=>{r("WebSocket connection failed"),I(!1)};let N=new AbortController,A=setInterval(()=>{P4(W0.current),W0.current=0},1000);return(async()=>{try{let S=(await fetch(i0,{signal:N.signal})).body?.getReader();if(!S)return;let h=new TextEncoder().encode("--frame");while(!0){let{done:l,value:u}=await S.read();if(l)break;if(u)for(let e0=0;e0<=u.length-h.length;e0++){let E4=!0;for(let I0=0;I0<h.length;I0++)if(u[e0+I0]!==h[I0]){E4=!1;break}if(E4)W0.current++}}}catch{}})(),()=>{N.abort(),clearInterval(A),H.close(),F.current=null}},[X,i0,_]),d(()=>{if(!_)return;let V=setInterval(()=>{P4(W0.current),W0.current=0},1000);return()=>clearInterval(V)},[_]);let e=j(()=>{return _?M.current:C.current},[_]),B0=j((V,H)=>{let N=e();if(!N)return;let A=N.getBoundingClientRect(),B=(H.clientX-A.left)/A.width,S=(H.clientY-A.top)/A.height;c({type:V,x:B,y:S})},[c]),Q0=3,a=w(!1),o=w(!1),u0=w(!1),r0=w({dx:0,dy:0}),V0=w(!1),[t0,F4]=p(!1),k4=w({x:0.5,y:0.5}),[q0,s]=p(null);d(()=>{let V=(N)=>{if(N.key==="Alt")F4(!0)},H=(N)=>{if(N.key==="Alt"){if(F4(!1),!o.current)s(null)}};return window.addEventListener("keydown",V),window.addEventListener("keyup",H),()=>{window.removeEventListener("keydown",V),window.removeEventListener("keyup",H)}},[]),d(()=>{if(t0&&!o.current){let V=k4.current;s({x1:V.x,y1:V.y,x2:1-V.x,y2:1-V.y})}else if(!t0&&!o.current)s(null)},[t0]);let _0=w(null),n0=w(!1),H0=w(0),I4=j((V,H)=>{n0.current=!0;let N=_0.current;if(N)cancelAnimationFrame(H0.current),H0.current=requestAnimationFrame(()=>{N.style.left=`${V*100}%`,N.style.top=`${H*100}%`,N.style.display="block"})},[]),M4=j((V,H)=>{if(!n0.current)return;let N=_0.current;if(N)cancelAnimationFrame(H0.current),H0.current=requestAnimationFrame(()=>{N.style.left=`${V*100}%`,N.style.top=`${H*100}%`})},[]),F0=j(()=>{n0.current=!1;let V=_0.current;if(V)cancelAnimationFrame(H0.current),V.style.display="none"},[]),C4=w(0),O0=w(null),v5=j(()=>{let V=Date.now(),H=V-C4.current;if(C4.current=V,H<300){if(O0.current)clearTimeout(O0.current),O0.current=null;if(K)K();else o0("app_switcher")}else O0.current=setTimeout(()=>{if(K)K();else o0("home");O0.current=null},300)},[o0,K]),k0=(()=>{if(!f||!m)return null;if(m.width===0||m.height===0)return null;let V=Math.min(m.width/f.width,m.height/f.height);return{width:f.width*V,height:f.height*V}})();return $("div",{style:{display:"flex",flexDirection:"column",flex:1,...O?{}:{border:"1px solid rgba(255,255,255,0.12)"},overflow:"hidden",minWidth:0,minHeight:0,...Z},className:q,children:[$("div",{ref:y,style:{position:"relative",flex:1,minHeight:0,minWidth:0,display:"flex",alignItems:"center",justifyContent:"center"},children:$("div",{style:{position:"relative",width:k0?`${k0.width}px`:"100%",height:k0?`${k0.height}px`:"100%"},children:[$("img",{ref:C,src:_?void 0:i0,draggable:!1,onLoad:(V)=>{let H=V.currentTarget;if(H.naturalWidth>0&&H.naturalHeight>0)i((N)=>N&&N.width===H.naturalWidth&&N.height===H.naturalHeight?N:{width:H.naturalWidth,height:H.naturalHeight})},style:_?{display:"none"}:{position:"absolute",inset:0,width:"100%",height:"100%",cursor:O4,display:"block",userSelect:"none",WebkitUserSelect:"none",touchAction:"none",...J}}),_&&$("img",{ref:M,draggable:!1,onLoad:(V)=>{let H=V.currentTarget;if(H.naturalWidth>0&&H.naturalHeight>0)i((N)=>N&&N.width===H.naturalWidth&&N.height===H.naturalHeight?N:{width:H.naturalWidth,height:H.naturalHeight})},style:{position:"absolute",inset:0,width:"100%",height:"100%",cursor:O4,display:"block",userSelect:"none",WebkitUserSelect:"none",touchAction:"none",...J}}),$("div",{style:{position:"absolute",inset:0,cursor:O4,touchAction:"none"},onMouseDown:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(V.altKey){o.current=!0,u0.current=V.shiftKey;let S={x1:A,y1:B,x2:1-A,y2:1-B};r0.current={dx:1-A-A,dy:1-B-B},s(S),n({type:"begin",...S});return}if(I4(A,B),B>0.88)a.current=!0,c({type:"begin",x:A,y:B,edge:Q0});else a.current=!1,B0("begin",V)},onMouseMove:(V)=>{let H=e();if(!H)return;let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(k4.current={x:A,y:B},V.buttons===0){if(V.altKey)s({x1:A,y1:B,x2:1-A,y2:1-B});return}if(o.current){let S;if(u0.current){let h=r0.current;S={x1:A,y1:B,x2:A+h.dx,y2:B+h.dy}}else S={x1:A,y1:B,x2:1-A,y2:1-B};s(S),n({type:"move",...S});return}if(M4(A,B),a.current)c({type:"move",x:A,y:B,edge:Q0});else B0("move",V)},onMouseUp:(V)=>{if(o.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(u0.current){let S=r0.current;n({type:"end",x1:A,y1:B,x2:A+S.dx,y2:B+S.dy})}else n({type:"end",x1:A,y1:B,x2:1-A,y2:1-B})}if(o.current=!1,!V.altKey)s(null);return}if(F0(),a.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;c({type:"end",x:A,y:B,edge:Q0})}a.current=!1;return}B0("end",V)},onMouseLeave:(V)=>{if(o.current){if(q0)n({type:"end",...q0});o.current=!1,s(null);return}if(F0(),a.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;c({type:"end",x:A,y:B,edge:Q0})}a.current=!1;return}if(V.buttons>0)B0("end",V);s(null)},onTouchStart:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V.touches.length>=2){F0();let h=V.touches[0],l=V.touches[1],u={x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:(l.clientX-N.left)/N.width,y2:(l.clientY-N.top)/N.height};if(!V0.current&&!a.current)c({type:"end",x:u.x1,y:u.y1});V0.current=!0,o.current=!0,a.current=!1,s(u),n({type:"begin",...u});return}let A=V.touches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(I4(B,S),S>0.88)a.current=!0,c({type:"begin",x:B,y:S,edge:Q0});else a.current=!1,c({type:"begin",x:B,y:S})},onTouchMove:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V0.current&&V.touches.length>=2){let h=V.touches[0],l=V.touches[1],u={x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:(l.clientX-N.left)/N.width,y2:(l.clientY-N.top)/N.height};s(u),n({type:"move",...u});return}let A=V.touches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(M4(B,S),a.current)c({type:"move",x:B,y:S,edge:Q0});else c({type:"move",x:B,y:S})},onTouchEnd:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V0.current){if(V.touches.length<2){let h=V.changedTouches[0],l=q0;if(h&&l)n({type:"end",x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:l.x2,y2:l.y2});else if(l)n({type:"end",...l});V0.current=!1,o.current=!1,s(null)}return}let A=V.changedTouches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(F0(),a.current)c({type:"end",x:B,y:S,edge:Q0}),a.current=!1;else c({type:"end",x:B,y:S})}}),$("div",{ref:_0,"data-testid":"touch-indicator",style:{position:"absolute",display:"none",width:24,height:24,borderRadius:"50%",background:"rgba(59,130,246,0.5)",boxShadow:"0 0 8px rgba(59,130,246,0.3)",transform:"translate(-50%, -50%)",pointerEvents:"none"}}),q0&&$(x,{children:[$("div",{"data-testid":"finger-dot",style:b5(q0.x1,q0.y1)}),$("div",{"data-testid":"finger-dot",style:b5(q0.x2,q0.y2)})]}),!E&&!v&&$("div",{style:S5,children:$("span",{style:{color:"#888",fontSize:14},children:"Connecting..."})}),v&&$("div",{style:S5,children:$("span",{style:{color:"#f44",fontSize:14,padding:20,textAlign:"center"},children:v})}),p5&&$("div",{style:A6,children:$("span",{style:{color:"#fbbf24",fontSize:13,fontFamily:"monospace"},children:"Slow connection"})})]})}),!O&&$("div",{style:{display:"flex",alignItems:"center",justifyContent:"space-between",padding:"4px 8px",borderTop:"1px solid rgba(255,255,255,0.12)"},children:[$("button",{onClick:v5,style:{background:"none",border:"1px solid rgba(255,255,255,0.2)",color:"#aaa",fontSize:11,fontFamily:"monospace",padding:"2px 10px",cursor:"pointer",borderRadius:4},children:"Home"}),$("span",{style:{color:D4>0?"#4f4":"#888",fontSize:12,fontFamily:"monospace",display:"flex",alignItems:"center",gap:6},children:[k&&$("span",{"data-testid":"quality-dot",style:{width:8,height:8,borderRadius:"50%",display:"inline-block",background:k==="good"?"#4ade80":k==="degraded"?"#facc15":"#ef4444"}}),D4," fps"]})]})]})}var A6={position:"absolute",top:8,left:"50%",transform:"translateX(-50%)",background:"rgba(0,0,0,0.7)",borderRadius:6,padding:"4px 12px",pointerEvents:"none"},S5={position:"absolute",inset:0,display:"flex",alignItems:"center",justifyContent:"center",background:"rgba(0,0,0,0.8)"},T5=20;function b5(X,Y){return{position:"absolute",left:`${X*100}%`,top:`${Y*100}%`,width:T5,height:T5,borderRadius:"50%",background:"rgba(255,255,255,0.4)",border:"1px solid rgba(255,255,255,0.7)",transform:"translate(-50%, -50%)",pointerEvents:"none"}}function d0(X){if(!X)return"iphone";let Y=X.toLowerCase();if(Y.includes("ipad"))return"ipad";if(Y.includes("watch"))return"watch";if(Y.includes("vision"))return"vision";return"iphone"}var R={iphone:{width:427,height:881,bezelX:18,bezelY:18,innerRadius:55},ipad:{width:430,height:605,bezelX:16,bezelY:16,innerRadius:12},watch:{width:274,height:322,bezelX:12,bezelY:12,innerRadius:79},vision:{width:640,height:400,bezelX:12,bezelY:12,innerRadius:32}},U7=R.iphone.width,A7=R.iphone.height,D7=R.iphone.bezelX,P7=R.iphone.bezelY,B7=R.iphone.innerRadius;function U4(X="iphone"){let Y=R[X];return{top:`${Y.bezelY/Y.height*100}%`,left:`${Y.bezelX/Y.width*100}%`,right:`${Y.bezelX/Y.width*100}%`,bottom:`${Y.bezelY/Y.height*100}%`}}function m0(X="iphone"){let Y=R[X],Z=Y.width-2*Y.bezelX,J=Y.height-2*Y.bezelY;return`${Y.innerRadius/Z*100}% / ${Y.innerRadius/J*100}%`}function h0({type:X="iphone",streaming:Y=!1}){switch(X){case"ipad":return $(B6,{streaming:Y});case"watch":return $(_6,{streaming:Y});case"vision":return $(F6,{streaming:Y});default:return $(P6,{streaming:Y})}}function P6({streaming:X=!1}){return $("svg",{viewBox:"0 0 427 881",style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"chrome-filter0",x:"-0.166992",y:"0.166504",width:"427",height:"880.667",filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"effect1_foregroundBlur"})]}),$("filter",{id:"chrome-filter1",x:"6.33236",y:"6.33382",width:"414",height:"868",filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333333",result:"effect1_foregroundBlur"})]})]}),$("rect",{x:"3.83268",y:"3.83366",width:"419",height:"873",rx:"66.1667",stroke:"#454548",strokeWidth:"4.33333"}),$("rect",{x:"0.833333",y:"0.833333",width:"425",height:"879",rx:"69.1667",stroke:"#37373a",strokeWidth:"1.66667"}),$("g",{opacity:"0.9",filter:"url(#chrome-filter0)",children:$("rect",{x:"1.66602",y:"2",width:"423.333",height:"877",rx:"68.6667",stroke:"#454548",strokeWidth:"1.66667"})}),$("g",{opacity:"0.8",filter:"url(#chrome-filter1)",children:$("rect",{x:"7.33268",y:"7.33366",width:"412",height:"866",rx:"62.6667",stroke:"#646464",strokeWidth:"0.666667"})}),$("rect",{x:"151.666",y:"31.667",width:"123.333",height:"36",rx:"18",fill:"black",style:{opacity:X?0:1,transition:"opacity 0.3s ease"}})]})}function B6({streaming:X=!1}){let Y=R.ipad.width,Z=R.ipad.height,J=30,q=26;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"ipad-glow0",x:"0",y:"0",width:Y,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]}),$("filter",{id:"ipad-glow1",x:"5",y:"5",width:Y-10,height:Z-10,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333333",result:"blur"})]})]}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:26,stroke:"#454548",strokeWidth:"4"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:30,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#ipad-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:29,stroke:"#454548",strokeWidth:"1.666"})}),$("g",{opacity:"0.8",filter:"url(#ipad-glow1)",children:$("rect",{x:"6",y:"6",width:Y-12,height:Z-12,rx:24,stroke:"#646464",strokeWidth:"0.666"})}),$("circle",{cx:Y/2,cy:R.ipad.bezelY/2+1,r:"3",fill:"#1a1a1a",style:{opacity:X?0:0.8,transition:"opacity 0.3s ease"}}),$("rect",{x:(Y-120)/2,y:Z-R.ipad.bezelY/2-2.5,width:"120",height:"5",rx:"2.5",fill:"white",style:{opacity:X?0:0.35,mixBlendMode:"difference",transition:"opacity 0.3s ease"}})]})}function _6({streaming:X=!1}){let Y=R.watch.width,Z=R.watch.height,J=88,q=82,K=8,Q=36,z=Z/2-18-16,G=22,L=Z/2-11+16;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%",overflow:"visible"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:$("filter",{id:"watch-glow0",x:"0",y:"0",width:Y+12,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]})}),$("rect",{x:Y-2,y:z,width:8,height:36,rx:"3",fill:"#2a2a2c",stroke:"#454548",strokeWidth:"1"}),$("rect",{x:Y-1,y:L,width:6,height:22,rx:"2.5",fill:"#2a2a2c",stroke:"#454548",strokeWidth:"0.8"}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:82,stroke:"#454548",strokeWidth:"3.5"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:88,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#watch-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:87,stroke:"#454548",strokeWidth:"1.666"})})]})}function F6({streaming:X=!1}){let Y=R.vision.width,Z=R.vision.height,J=40,q=34;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"vision-glow0",x:"0",y:"0",width:Y,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]}),$("filter",{id:"vision-glow1",x:"5",y:"5",width:Y-10,height:Z-10,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333",result:"blur"})]}),$("linearGradient",{id:"vision-glass",x1:"0",y1:"0",x2:"0",y2:"1",children:[$("stop",{offset:"0%",stopColor:"#555558",stopOpacity:"0.3"}),$("stop",{offset:"100%",stopColor:"#3a3a3d",stopOpacity:"0.1"})]})]}),$("rect",{x:"0",y:"0",width:Y,height:Z,rx:40,fill:"url(#vision-glass)"}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:34,stroke:"#454548",strokeWidth:"3"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:40,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#vision-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:39,stroke:"#454548",strokeWidth:"1.666"})}),$("g",{opacity:"0.8",filter:"url(#vision-glow1)",children:$("rect",{x:"6",y:"6",width:Y-12,height:Z-12,rx:32,stroke:"#646464",strokeWidth:"0.666"})}),$("ellipse",{cx:Y/2,cy:Z/2,rx:Y/2-30,ry:Z/2-24,stroke:"#4a4a4d",strokeWidth:"0.5",opacity:"0.3",style:{opacity:X?0:0.3,transition:"opacity 0.3s ease"}})]})}var A4=z0(null);function f0(X){let Y=P0(A4);if(!Y)throw Error(`<SimulatorToolbar.${X}> must be rendered inside <SimulatorToolbar>`);return Y}var M6={display:"flex",flexWrap:"wrap",alignItems:"center",justifyContent:"space-between",gap:"4px 12px",padding:"8px 12px",borderRadius:24,background:"#1c1c1e",border:"1px solid rgba(255,255,255,0.1)",boxShadow:"0 1px 2px rgba(0,0,0,0.2)",minWidth:240,width:"100%"};function C6({exec:X,deviceUdid:Y,deviceName:Z,deviceRuntime:J,streaming:q=!1,disabled:K=!1,children:Q,style:z,...G}){let L=d0(Z),W={exec:X,deviceUdid:Y,deviceName:Z,deviceRuntime:J,deviceType:L,streaming:q,disabled:K||!Y||!q};return $(A4.Provider,{value:W,children:$("div",{"data-simulator-toolbar":!0,style:{...M6,...z},...G,children:Q})})}var E6={display:"flex",flexDirection:"column",alignItems:"flex-start",textAlign:"left",background:"transparent",border:"none",color:"#fff",padding:"2px 4px",margin:"-2px -4px",borderRadius:6,cursor:"pointer",minWidth:0,maxWidth:"100%",lineHeight:1.2,fontFamily:"inherit"},w6=G0(function({name:Y,subtitle:Z,hideChevron:J,style:q,onMouseEnter:K,onMouseLeave:Q,...z},G){let L=f0("Title"),[D,W]=p(!1),O=Y??L.deviceName??"No simulator",U=Z??(L.deviceRuntime?L.deviceRuntime.replace(/\./," "):"—");return $("button",{ref:G,type:"button","data-simulator-toolbar-title":!0,onMouseEnter:(k)=>{W(!0),K?.(k)},onMouseLeave:(k)=>{W(!1),Q?.(k)},style:{...E6,background:D?"rgba(255,255,255,0.1)":"transparent",...q},...z,children:[$("span",{style:{display:"inline-flex",alignItems:"center",gap:4,fontSize:12,fontWeight:600,color:"#fff",maxWidth:"100%",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:[O,!J&&$("svg",{width:"10",height:"10",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2.5",strokeLinecap:"round",strokeLinejoin:"round",style:{color:"rgba(255,255,255,0.6)",flexShrink:0},children:$("polyline",{points:"6 9 12 15 18 9"})})]}),$("span",{style:{fontSize:10,color:"rgba(255,255,255,0.5)",maxWidth:"100%",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:U})]})}),S6={display:"flex",alignItems:"center",gap:4,flexShrink:0};function T6({style:X,...Y}){return $("div",{style:{...S6,...X},...Y})}var b6={background:"transparent",border:"none",padding:6,borderRadius:6,cursor:"pointer",display:"inline-flex",alignItems:"center",justifyContent:"center",color:"rgba(255,255,255,0.8)",transition:"background-color 0.15s, color 0.15s"},a0=G0(function({forceDisabled:Y,style:Z,disabled:J,onMouseEnter:q,onMouseLeave:K,children:Q,...z},G){let L=P0(A4),D=J||Y||L?.disabled,[W,O]=p(!1);return $("button",{ref:G,type:"button",disabled:D,onMouseEnter:(U)=>{O(!0),q?.(U)},onMouseLeave:(U)=>{O(!1),K?.(U)},style:{...b6,color:D?"rgba(255,255,255,0.25)":"rgba(255,255,255,0.8)",background:W&&!D?"rgba(255,255,255,0.1)":"transparent",cursor:D?"not-allowed":"pointer",...Z},...z,children:Q})});function p6(){return['tell application "System Events" to tell process "Simulator" to set frontmost to true','tell application "System Events" to tell process "Simulator" to perform action "AXRaise" of (first window whose name contains "watchOS")','tell application "System Events" to tell process "Simulator" to click menu item "Home" of menu "Device" of menu bar item "Device" of menu bar 1'].map((Y)=>`-e '${Y}'`).reduce((Y,Z)=>`${Y} ${Z}`,"osascript")}var v6=$("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",children:$("path",{d:"M3 10.5 12 3l9 7.5V20a1 1 0 0 1-1 1h-5v-7h-6v7H4a1 1 0 0 1-1-1z"})}),j6=$("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",children:[$("path",{d:"M14.5 4h-5L7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3z"}),$("circle",{cx:"12",cy:"13",r:"4"})]}),R6=$("svg",{width:"18",height:"18",viewBox:"0 0 12 13",fill:"currentColor",xmlns:"http://www.w3.org/2000/svg",children:$("path",{d:"M10.2305 12.8077H4.42383C3.92383 12.8077 3.54688 12.6846 3.29297 12.4385C3.04297 12.1963 2.91797 11.8194 2.91797 11.3077V5.51274C2.91797 4.99711 3.04297 4.61821 3.29297 4.37602C3.54688 4.12993 3.92383 4.00688 4.42383 4.00688H10.2305C10.7344 4.00688 11.1113 4.12993 11.3613 4.37602C11.6113 4.61821 11.7363 4.99711 11.7363 5.51274V11.3077C11.7363 11.8194 11.6113 12.1963 11.3613 12.4385C11.1113 12.6846 10.7344 12.8077 10.2305 12.8077ZM10.2129 11.8643C10.416 11.8643 10.5625 11.8194 10.6523 11.7295C10.7461 11.6436 10.793 11.4971 10.793 11.2901V5.52446C10.793 5.31743 10.7461 5.17094 10.6523 5.08501C10.5625 4.99516 10.416 4.95024 10.2129 4.95024H4.44141C4.24219 4.95024 4.0957 4.99516 4.00195 5.08501C3.9082 5.17094 3.86133 5.31743 3.86133 5.52446V11.2901C3.86133 11.4971 3.9082 11.6436 4.00195 11.7295C4.0957 11.8194 4.24219 11.8643 4.44141 11.8643H10.2129ZM2.91797 2.58305V0.415083C2.91797 0.20024 2.98633 0.0693803 3.12305 0.0225053C3.25977 -0.0282759 3.41016 0.00688033 3.57422 0.127974L5.05078 1.21196C5.17578 1.30571 5.23828 1.40141 5.23828 1.49907C5.23828 1.59672 5.17578 1.69243 5.05078 1.78618L3.57422 2.8643C3.41016 2.9854 3.25977 3.02251 3.12305 2.97563C2.98633 2.92485 2.91797 2.79399 2.91797 2.58305ZM3.5332 1.15336C3.62695 1.15336 3.70703 1.18657 3.77344 1.25297C3.84375 1.31938 3.87891 1.39751 3.87891 1.48735C3.87891 1.5811 3.84375 1.66313 3.77344 1.73344C3.70703 1.79985 3.62695 1.83305 3.5332 1.83305H2.80664C2.38086 1.83305 2.01172 1.92485 1.69922 2.10844C1.39062 2.28813 1.15234 2.53813 0.984375 2.85844C0.816406 3.17876 0.732422 3.54594 0.732422 3.96001V4.83891C0.732422 4.93657 0.697266 5.02251 0.626953 5.09672C0.552734 5.16704 0.464844 5.20219 0.363281 5.20219C0.265625 5.20219 0.181641 5.16704 0.111328 5.09672C0.0371094 5.02251 0 4.93657 0 4.83891V3.96001C0 3.40141 0.117188 2.91118 0.351562 2.4893C0.582031 2.06743 0.908203 1.7393 1.33008 1.50493C1.74805 1.27055 2.23828 1.15336 2.80078 1.15336H3.5332Z"})}),y6=G0(function({onClick:Y,...Z},J){let q=f0("HomeButton");return $(a0,{ref:J,"aria-label":"Home",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceType==="watch")q.exec(p6());else q.exec("serve-sim button home")},...Z,children:v6})}),g6=G0(function({onClick:Y,...Z},J){let q=f0("ScreenshotButton");return $(a0,{ref:J,"aria-label":"Screenshot",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceUdid)q.exec(`xcrun simctl io ${q.deviceUdid} screenshot ~/Desktop/hatch-screenshot-$(date +%s).png`)},...Z,children:j6})}),x6=G0(function({onClick:Y,...Z},J){let q=f0("RotateButton");return $(a0,{ref:J,"aria-label":"Rotate device",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceUdid)q.exec(`osascript -e 'tell application "Simulator" to activate' -e 'tell application "System Events" to key code 124 using {command down}'`)},...Z,children:R6})}),$0=C6;$0.Title=w6;$0.Actions=T6;$0.Button=a0;$0.HomeButton=y6;$0.ScreenshotButton=g6;$0.RotateButton=x6;function d6(X){let[Y,Z]=p(null),J=w(new Set),[q,K]=p(null),Q=j((z)=>{return J.current.add(z),()=>{J.current.delete(z)}},[]);return d(()=>{if(!X)return;let z=new AbortController,G=X.replace(/\/stream\.mjpeg$/,"");return fetch(`${G}/config`,{signal:z.signal}).then((L)=>L.json()).then((L)=>{if(L.width>0&&L.height>0)Z(L)}).catch(()=>{}),(async()=>{try{let D=(await fetch(X,{signal:z.signal})).body?.getReader();if(!D)return;let W=new Uint8Array(0);while(!0){let{done:O,value:U}=await D.read();if(O)break;let k=new Uint8Array(W.length+U.length);k.set(W),k.set(U,W.length),W=k;while(!0){let _=-1;for(let I=0;I<W.length-1;I++)if(W[I]===255&&W[I+1]===216){_=I;break}if(_===-1)break;let C=-1;for(let I=_+2;I<W.length-1;I++)if(W[I]===255&&W[I+1]===217){C=I+2;break}if(C===-1)break;let M=W.slice(_,C);W=W.slice(C);let F=new Blob([M],{type:"image/jpeg"}),E=URL.createObjectURL(F);K(E);for(let I of J.current)I(E)}}}catch{}})(),()=>z.abort()},[X]),{subscribeFrame:Q,frame:q,config:Y}}function m6(){let X=window.__SIM_PREVIEW__,[Y,Z]=p(!1);if(d(()=>{if(!X?.logsEndpoint)return;let O=new EventSource(X.logsEndpoint),U=new Map,k=["#8be9fd","#50fa7b","#ffb86c","#ff79c6","#bd93f9","#f1fa8c","#6272a4","#ff5555","#69ff94","#d6acff","#ffffa5","#a4ffff","#ff6e6e","#caa9fa","#5af78e"];function _(F){let E=U.get(F);if(!E){let I=0;for(let v=0;v<F.length;v++)I=(I<<5)-I+F.charCodeAt(v)|0;E=k[Math.abs(I)%k.length],U.set(F,E)}return E}let C="",M=!1;return O.onmessage=(F)=>{try{let E=JSON.parse(F.data),I=E.processImagePath?.split("/").pop()??E.senderImagePath?.split("/").pop()??"",v=E.subsystem??"",r=E.category??"",f=E.eventMessage??"";if(!f)return;if(I!==C){if(M)console.groupEnd();let c0=_(I);console.groupCollapsed(`%c${I}${v?` %c${v}${r?":"+r:""}`:""}`,`color:${c0};font-weight:bold`,...v?["color:#888;font-weight:normal"]:[]),M=!0,C=I}let i=(E.messageType??"").toLowerCase(),y=v&&I===C?`%c${r||v}%c `:"",m=y?["color:#888;font-style:italic","color:inherit"]:[];if(i==="fault"||i==="error")console.log(`${y}%c${f}`,...m,"color:#ff5555");else if(i==="debug")console.log(`${y}%c${f}`,...m,"color:#6272a4");else console.log(`${y}%c${f}`,...m,"color:inherit")}catch{}},()=>{if(M)console.groupEnd();O.close()}},[X?.logsEndpoint]),!X)return $("div",{style:J0.page,children:$("div",{style:J0.empty,children:[$("h1",{style:J0.emptyTitle,children:"No serve-sim stream running"}),$("p",{style:J0.emptyHint,children:["Boot an iOS simulator and start a Hatch stream with"," ",$("code",{style:J0.code,children:"bunx serve-sim --detach"}),", then reload."]})]})});let J=R.iphone,q=U4("iphone"),K=m0("iphone"),Q=d6(X.streamUrl),z=w(null);d(()=>{let O=new WebSocket(X.wsUrl);return O.binaryType="arraybuffer",z.current=O,()=>{O.close(),z.current=null}},[X.wsUrl]);let G=j((O,U)=>{let k=z.current;if(!k||k.readyState!==WebSocket.OPEN)return;let _=new TextEncoder().encode(JSON.stringify(U)),C=new Uint8Array(1+_.length);C[0]=O,C.set(_,1),k.send(C)},[]),L=j((O)=>G(3,O),[G]),D=j((O)=>G(5,O),[G]),W=j((O)=>G(4,{button:O}),[G]);return $("div",{style:J0.page,children:[$("div",{style:{position:"relative",maxWidth:320,width:"100%",aspectRatio:`${J.width} / ${J.height}`},children:[$("div",{style:{position:"absolute",...q},children:$(x0,{url:X.url,style:{width:"100%",height:"100%",border:"none"},imageStyle:{borderRadius:K,cornerShape:"superellipse(1.3)"},hideControls:!0,onStreamingChange:Z,onStreamTouch:L,onStreamMultiTouch:D,onStreamButton:W,subscribeFrame:Q.subscribeFrame,streamFrame:Q.frame,streamConfig:Q.config})}),$("div",{style:{position:"absolute",inset:0,pointerEvents:"none",zIndex:10},children:$(h0,{type:"iphone",streaming:Y})})]}),$("div",{style:J0.bar,children:$("span",{style:{...J0.live,color:Y?"#4ade80":"#666"},children:[$("span",{style:{...J0.dot,background:Y?"#4ade80":"#666"}}),Y?"live":"connecting"]})})]})}var J0={page:{display:"flex",flexDirection:"column",alignItems:"center",justifyContent:"center",height:"100vh",background:"#0a0a0a",padding:24,gap:12,fontFamily:"-apple-system, system-ui, sans-serif"},bar:{display:"flex",alignItems:"center",gap:10,fontSize:12,fontFamily:"ui-monospace, monospace",color:"#666"},live:{display:"flex",alignItems:"center",gap:5,transition:"color 0.3s"},dot:{width:6,height:6,borderRadius:"50%",transition:"background 0.3s"},empty:{display:"flex",flexDirection:"column",alignItems:"center",gap:12,textAlign:"center"},emptyTitle:{fontSize:18,margin:0,color:"#eee"},emptyHint:{color:"#888",fontSize:14,maxWidth:480},code:{background:"#222",padding:"2px 6px",borderRadius:4,fontSize:13}};H5(document.getElementById("root")).render($(m6,{}));
</script>
</body></html>","base64").toString("utf-8");return $}function y(U){let B=(U?.basePath??"/.sim").replace(/\/+$/,"");return(G,z,w)=>{let M=G.url??"";if(M===B||M===B+"/"){let V=Z()[0]??null,K=D();if(V){let X=`<script>window.__SIM_PREVIEW__=${JSON.stringify({...V,logsEndpoint:B+"/logs"})}</script>`;K=K.replace("<!--__SIM_PREVIEW_CONFIG__-->",X)}z.writeHead(200,{"Content-Type":"text/html; charset=utf-8","Cache-Control":"no-store"}),z.end(K);return}if(M===B+"/api"){let Q=Z();z.writeHead(200,{"Content-Type":"application/json","Cache-Control":"no-store"}),z.end(JSON.stringify(Q[0]||null));return}if(M===B+"/logs"||M.startsWith(B+"/logs?")){let Q=Z();if(Q.length===0){z.writeHead(404),z.end("No serve-sim device");return}let V=Q[0].device;z.writeHead(200,{"Content-Type":"text/event-stream","Cache-Control":"no-cache",Connection:"keep-alive","X-Accel-Buffering":"no"}),z.write(`:
+
+`);let K=j("xcrun",["simctl","spawn",V,"log","stream","--style","ndjson","--level","info"],{stdio:["ignore","pipe","ignore"]}),L="";K.stdout.on("data",(X)=>{L+=X.toString();let Y;while((Y=L.indexOf(`
+`))!==-1){let C=L.slice(0,Y).trim();if(L=L.slice(Y+1),C)z.write("data: "+C+`
+
+`)}}),K.on("close",()=>z.end()),G.on("close",()=>K.kill());return}if(w)w()}}export{y as simMiddleware};

package/dist/serve-sim.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+// @bun
+var $e=Object.defineProperty;var ye=(e,_)=>{for(var t in _)$e(e,t,{get:_[t],enumerable:!0,configurable:!0,set:(C)=>_[t]=()=>C})};var ce=(e,_)=>()=>(e&&(_=e(e=0)),_);var U={};ye(U,{simMiddleware:()=>ge});import{readdirSync as pe,readFileSync as He}from"fs";import{spawn as Te}from"child_process";import{tmpdir as ue}from"os";import{join as P}from"path";function N(){let e;try{e=pe(k).filter((t)=>t.startsWith("server-")&&t.endsWith(".json"))}catch{return[]}let _=[];for(let t of e)try{let C=JSON.parse(He(P(k,t),"utf-8"));try{process.kill(C.pid,0),_.push(C)}catch{}}catch{}return _}function le(){if(!V)V=Buffer.from("<!doctype html>
<html><head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Simulator Preview</title>
<style>*,*::before,*::after{box-sizing:border-box}html,body{margin:0;height:100%;overflow:hidden}</style>
</head><body>
<div id="root"></div>
<!--__SIM_PREVIEW_CONFIG__-->
<script type="module">var b0,P,b4,j5,K0,w4,p4,v4,X4,C0,U0,j4,K4,Y4,Z4,R4,w0={},S0=[],R5=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,A0=Array.isArray;function X0(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function Q4(X){X&&X.parentNode&&X.parentNode.removeChild(X)}function Y0(X,Y,Z){var J,q,K,Q={};for(K in Y)K=="key"?J=Y[K]:K=="ref"?q=Y[K]:Q[K]=Y[K];if(arguments.length>2&&(Q.children=arguments.length>3?b0.call(arguments,2):Z),typeof X=="function"&&X.defaultProps!=null)for(K in X.defaultProps)Q[K]===void 0&&(Q[K]=X.defaultProps[K]);return E0(X,Q,J,q,null)}function E0(X,Y,Z,J,q){var K={type:X,props:Y,key:Z,ref:J,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:q==null?++b4:q,__i:-1,__u:0};return q==null&&P.vnode!=null&&P.vnode(K),K}function x(X){return X.children}function g(X,Y){this.props=X,this.context=Y}function L0(X,Y){if(Y==null)return X.__?L0(X.__,X.__i+1):null;for(var Z;Y<X.__k.length;Y++)if((Z=X.__k[Y])!=null&&Z.__e!=null)return Z.__e;return typeof X.type=="function"?L0(X):null}function y5(X){if(X.__P&&X.__d){var Y=X.__v,Z=Y.__e,J=[],q=[],K=X0({},Y);K.__v=Y.__v+1,P.vnode&&P.vnode(K),$4(X.__P,K,Y,X.__n,X.__P.namespaceURI,32&Y.__u?[Z]:null,J,Z==null?L0(Y):Z,!!(32&Y.__u),q),K.__v=Y.__v,K.__.__k[K.__i]=K,d4(J,K,q),Y.__e=Y.__=null,K.__e!=Z&&y4(K)}}function y4(X){if((X=X.__)!=null&&X.__c!=null)return X.__e=X.__c.base=null,X.__k.some(function(Y){if(Y!=null&&Y.__e!=null)return X.__e=X.__c.base=Y.__e}),y4(X)}function J4(X){(!X.__d&&(X.__d=!0)&&K0.push(X)&&!T0.__r++||w4!=P.debounceRendering)&&((w4=P.debounceRendering)||p4)(T0)}function T0(){try{for(var X,Y=1;K0.length;)K0.length>Y&&K0.sort(v4),X=K0.shift(),Y=K0.length,y5(X)}finally{K0.length=T0.__r=0}}function g4(X,Y,Z,J,q,K,Q,z,G,L,D){var W,O,U,k,_,C,M,F=J&&J.__k||S0,E=Y.length;for(G=g5(Z,Y,F,G,E),W=0;W<E;W++)(U=Z.__k[W])!=null&&(O=U.__i!=-1&&F[U.__i]||w0,U.__i=W,C=$4(X,U,O,q,K,Q,z,G,L,D),k=U.__e,U.ref&&O.ref!=U.ref&&(O.ref&&W4(O.ref,null,U),D.push(U.ref,U.__c||k,U)),_==null&&k!=null&&(_=k),(M=!!(4&U.__u))||O.__k===U.__k?(G=x4(U,G,X,M),M&&O.__e&&(O.__e=null)):typeof U.type=="function"&&C!==void 0?G=C:k&&(G=k.nextSibling),U.__u&=-7);return Z.__e=_,G}function g5(X,Y,Z,J,q){var K,Q,z,G,L,D=Z.length,W=D,O=0;for(X.__k=Array(q),K=0;K<q;K++)(Q=Y[K])!=null&&typeof Q!="boolean"&&typeof Q!="function"?(typeof Q=="string"||typeof Q=="number"||typeof Q=="bigint"||Q.constructor==String?Q=X.__k[K]=E0(null,Q,null,null,null):A0(Q)?Q=X.__k[K]=E0(x,{children:Q},null,null,null):Q.constructor===void 0&&Q.__b>0?Q=X.__k[K]=E0(Q.type,Q.props,Q.key,Q.ref?Q.ref:null,Q.__v):X.__k[K]=Q,G=K+O,Q.__=X,Q.__b=X.__b+1,z=null,(L=Q.__i=x5(Q,Z,G,W))!=-1&&(W--,(z=Z[L])&&(z.__u|=2)),z==null||z.__v==null?(L==-1&&(q>D?O--:q<D&&O++),typeof Q.type!="function"&&(Q.__u|=4)):L!=G&&(L==G-1?O--:L==G+1?O++:(L>G?O--:O++,Q.__u|=4))):X.__k[K]=null;if(W)for(K=0;K<D;K++)(z=Z[K])!=null&&(2&z.__u)==0&&(z.__e==J&&(J=L0(z)),h4(z,z));return J}function x4(X,Y,Z,J){var q,K;if(typeof X.type=="function"){for(q=X.__k,K=0;q&&K<q.length;K++)q[K]&&(q[K].__=X,Y=x4(q[K],Y,Z,J));return Y}X.__e!=Y&&(J&&(Y&&X.type&&!Y.parentNode&&(Y=L0(X)),Z.insertBefore(X.__e,Y||null)),Y=X.__e);do Y=Y&&Y.nextSibling;while(Y!=null&&Y.nodeType==8);return Y}function Z0(X,Y){return Y=Y||[],X==null||typeof X=="boolean"||(A0(X)?X.some(function(Z){Z0(Z,Y)}):Y.push(X)),Y}function x5(X,Y,Z,J){var q,K,Q,z=X.key,G=X.type,L=Y[Z],D=L!=null&&(2&L.__u)==0;if(L===null&&z==null||D&&z==L.key&&G==L.type)return Z;if(J>(D?1:0)){for(q=Z-1,K=Z+1;q>=0||K<Y.length;)if((L=Y[Q=q>=0?q--:K++])!=null&&(2&L.__u)==0&&z==L.key&&G==L.type)return Q}return-1}function S4(X,Y,Z){Y[0]=="-"?X.setProperty(Y,Z==null?"":Z):X[Y]=Z==null?"":typeof Z!="number"||R5.test(Y)?Z:Z+"px"}function M0(X,Y,Z,J,q){var K,Q;X:if(Y=="style")if(typeof Z=="string")X.style.cssText=Z;else{if(typeof J=="string"&&(X.style.cssText=J=""),J)for(Y in J)Z&&Y in Z||S4(X.style,Y,"");if(Z)for(Y in Z)J&&Z[Y]==J[Y]||S4(X.style,Y,Z[Y])}else if(Y[0]=="o"&&Y[1]=="n")K=Y!=(Y=Y.replace(j4,"$1")),Q=Y.toLowerCase(),Y=Q in X||Y=="onFocusOut"||Y=="onFocusIn"?Q.slice(2):Y.slice(2),X.l||(X.l={}),X.l[Y+K]=Z,Z?J?Z[U0]=J[U0]:(Z[U0]=K4,X.addEventListener(Y,K?Z4:Y4,K)):X.removeEventListener(Y,K?Z4:Y4,K);else{if(q=="http://www.w3.org/2000/svg")Y=Y.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(Y!="width"&&Y!="height"&&Y!="href"&&Y!="list"&&Y!="form"&&Y!="tabIndex"&&Y!="download"&&Y!="rowSpan"&&Y!="colSpan"&&Y!="role"&&Y!="popover"&&Y in X)try{X[Y]=Z==null?"":Z;break X}catch(z){}typeof Z=="function"||(Z==null||Z===!1&&Y[4]!="-"?X.removeAttribute(Y):X.setAttribute(Y,Y=="popover"&&Z==1?"":Z))}}function T4(X){return function(Y){if(this.l){var Z=this.l[Y.type+X];if(Y[C0]==null)Y[C0]=K4++;else if(Y[C0]<Z[U0])return;return Z(P.event?P.event(Y):Y)}}}function $4(X,Y,Z,J,q,K,Q,z,G,L){var D,W,O,U,k,_,C,M,F,E,I,v,r,f,i,y=Y.type;if(Y.constructor!==void 0)return null;128&Z.__u&&(G=!!(32&Z.__u),K=[z=Y.__e=Z.__e]),(D=P.__b)&&D(Y);X:if(typeof y=="function")try{if(M=Y.props,F=y.prototype&&y.prototype.render,E=(D=y.contextType)&&J[D.__c],I=D?E?E.props.value:D.__:J,Z.__c?C=(W=Y.__c=Z.__c).__=W.__E:(F?Y.__c=W=new y(M,I):(Y.__c=W=new g(M,I),W.constructor=y,W.render=m5),E&&E.sub(W),W.state||(W.state={}),W.__n=J,O=W.__d=!0,W.__h=[],W._sb=[]),F&&W.__s==null&&(W.__s=W.state),F&&y.getDerivedStateFromProps!=null&&(W.__s==W.state&&(W.__s=X0({},W.__s)),X0(W.__s,y.getDerivedStateFromProps(M,W.__s))),U=W.props,k=W.state,W.__v=Y,O)F&&y.getDerivedStateFromProps==null&&W.componentWillMount!=null&&W.componentWillMount(),F&&W.componentDidMount!=null&&W.__h.push(W.componentDidMount);else{if(F&&y.getDerivedStateFromProps==null&&M!==U&&W.componentWillReceiveProps!=null&&W.componentWillReceiveProps(M,I),Y.__v==Z.__v||!W.__e&&W.shouldComponentUpdate!=null&&W.shouldComponentUpdate(M,W.__s,I)===!1){Y.__v!=Z.__v&&(W.props=M,W.state=W.__s,W.__d=!1),Y.__e=Z.__e,Y.__k=Z.__k,Y.__k.some(function(m){m&&(m.__=Y)}),S0.push.apply(W.__h,W._sb),W._sb=[],W.__h.length&&Q.push(W);break X}W.componentWillUpdate!=null&&W.componentWillUpdate(M,W.__s,I),F&&W.componentDidUpdate!=null&&W.__h.push(function(){W.componentDidUpdate(U,k,_)})}if(W.context=I,W.props=M,W.__P=X,W.__e=!1,v=P.__r,r=0,F)W.state=W.__s,W.__d=!1,v&&v(Y),D=W.render(W.props,W.state,W.context),S0.push.apply(W.__h,W._sb),W._sb=[];else do W.__d=!1,v&&v(Y),D=W.render(W.props,W.state,W.context),W.state=W.__s;while(W.__d&&++r<25);W.state=W.__s,W.getChildContext!=null&&(J=X0(X0({},J),W.getChildContext())),F&&!O&&W.getSnapshotBeforeUpdate!=null&&(_=W.getSnapshotBeforeUpdate(U,k)),f=D!=null&&D.type===x&&D.key==null?m4(D.props.children):D,z=g4(X,A0(f)?f:[f],Y,Z,J,q,K,Q,z,G,L),W.base=Y.__e,Y.__u&=-161,W.__h.length&&Q.push(W),C&&(W.__E=W.__=null)}catch(m){if(Y.__v=null,G||K!=null)if(m.then){for(Y.__u|=G?160:128;z&&z.nodeType==8&&z.nextSibling;)z=z.nextSibling;K[K.indexOf(z)]=null,Y.__e=z}else{for(i=K.length;i--;)Q4(K[i]);q4(Y)}else Y.__e=Z.__e,Y.__k=Z.__k,m.then||q4(Y);P.__e(m,Y,Z)}else K==null&&Y.__v==Z.__v?(Y.__k=Z.__k,Y.__e=Z.__e):z=Y.__e=d5(Z.__e,Y,Z,J,q,K,Q,G,L);return(D=P.diffed)&&D(Y),128&Y.__u?void 0:z}function q4(X){X&&(X.__c&&(X.__c.__e=!0),X.__k&&X.__k.some(q4))}function d4(X,Y,Z){for(var J=0;J<Z.length;J++)W4(Z[J],Z[++J],Z[++J]);P.__c&&P.__c(Y,X),X.some(function(q){try{X=q.__h,q.__h=[],X.some(function(K){K.call(q)})}catch(K){P.__e(K,q.__v)}})}function m4(X){return typeof X!="object"||X==null||X.__b>0?X:A0(X)?X.map(m4):X0({},X)}function d5(X,Y,Z,J,q,K,Q,z,G){var L,D,W,O,U,k,_,C=Z.props||w0,M=Y.props,F=Y.type;if(F=="svg"?q="http://www.w3.org/2000/svg":F=="math"?q="http://www.w3.org/1998/Math/MathML":q||(q="http://www.w3.org/1999/xhtml"),K!=null){for(L=0;L<K.length;L++)if((U=K[L])&&"setAttribute"in U==!!F&&(F?U.localName==F:U.nodeType==3)){X=U,K[L]=null;break}}if(X==null){if(F==null)return document.createTextNode(M);X=document.createElementNS(q,F,M.is&&M),z&&(P.__m&&P.__m(Y,K),z=!1),K=null}if(F==null)C===M||z&&X.data==M||(X.data=M);else{if(K=K&&b0.call(X.childNodes),!z&&K!=null)for(C={},L=0;L<X.attributes.length;L++)C[(U=X.attributes[L]).name]=U.value;for(L in C)U=C[L],L=="dangerouslySetInnerHTML"?W=U:L=="children"||(L in M)||L=="value"&&("defaultValue"in M)||L=="checked"&&("defaultChecked"in M)||M0(X,L,null,U,q);for(L in M)U=M[L],L=="children"?O=U:L=="dangerouslySetInnerHTML"?D=U:L=="value"?k=U:L=="checked"?_=U:z&&typeof U!="function"||C[L]===U||M0(X,L,U,C[L],q);if(D)z||W&&(D.__html==W.__html||D.__html==X.innerHTML)||(X.innerHTML=D.__html),Y.__k=[];else if(W&&(X.innerHTML=""),g4(Y.type=="template"?X.content:X,A0(O)?O:[O],Y,Z,J,F=="foreignObject"?"http://www.w3.org/1999/xhtml":q,K,Q,K?K[0]:Z.__k&&L0(Z,0),z,G),K!=null)for(L=K.length;L--;)Q4(K[L]);z||(L="value",F=="progress"&&k==null?X.removeAttribute("value"):k!=null&&(k!==X[L]||F=="progress"&&!k||F=="option"&&k!=C[L])&&M0(X,L,k,C[L],q),L="checked",_!=null&&_!=X[L]&&M0(X,L,_,C[L],q))}return X}function W4(X,Y,Z){try{if(typeof X=="function"){var J=typeof X.__u=="function";J&&X.__u(),J&&Y==null||(X.__u=X(Y))}else X.current=Y}catch(q){P.__e(q,Z)}}function h4(X,Y,Z){var J,q;if(P.unmount&&P.unmount(X),(J=X.ref)&&(J.current&&J.current!=X.__e||W4(J,null,Y)),(J=X.__c)!=null){if(J.componentWillUnmount)try{J.componentWillUnmount()}catch(K){P.__e(K,Y)}J.base=J.__P=null}if(J=X.__k)for(q=0;q<J.length;q++)J[q]&&h4(J[q],Y,Z||typeof X.type!="function");Z||Q4(X.__e),X.__c=X.__=X.__e=void 0}function m5(X,Y,Z){return this.constructor(X,Z)}function p0(X,Y,Z){var J,q,K,Q;Y==document&&(Y=document.documentElement),P.__&&P.__(X,Y),q=(J=typeof Z=="function")?null:Z&&Z.__k||Y.__k,K=[],Q=[],$4(Y,X=(!J&&Z||Y).__k=Y0(x,null,[X]),q||w0,w0,Y.namespaceURI,!J&&Z?[Z]:q?null:Y.firstChild?b0.call(Y.childNodes):null,K,!J&&Z?Z:q?q.__e:Y.firstChild,J,Q),d4(K,X,Q)}function z0(X){function Y(Z){var J,q;return this.getChildContext||(J=new Set,(q={})[Y.__c]=this,this.getChildContext=function(){return q},this.componentWillUnmount=function(){J=null},this.shouldComponentUpdate=function(K){this.props.value!=K.value&&J.forEach(function(Q){Q.__e=!0,J4(Q)})},this.sub=function(K){J.add(K);var Q=K.componentWillUnmount;K.componentWillUnmount=function(){J&&J.delete(K),Q&&Q.call(K)}}),Z.children}return Y.__c="__cC"+R4++,Y.__=X,Y.Provider=Y.__l=(Y.Consumer=function(Z,J){return Z.children(J)}).contextType=Y,Y}b0=S0.slice,P={__e:function(X,Y,Z,J){for(var q,K,Q;Y=Y.__;)if((q=Y.__c)&&!q.__)try{if((K=q.constructor)&&K.getDerivedStateFromError!=null&&(q.setState(K.getDerivedStateFromError(X)),Q=q.__d),q.componentDidCatch!=null&&(q.componentDidCatch(X,J||{}),Q=q.__d),Q)return q.__E=q}catch(z){X=z}throw X}},b4=0,j5=function(X){return X!=null&&X.constructor===void 0},g.prototype.setState=function(X,Y){var Z;Z=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=X0({},this.state),typeof X=="function"&&(X=X(X0({},Z),this.props)),X&&X0(Z,X),X!=null&&this.__v&&(Y&&this._sb.push(Y),J4(this))},g.prototype.forceUpdate=function(X){this.__v&&(this.__e=!0,X&&this.__h.push(X),J4(this))},g.prototype.render=x,K0=[],p4=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,v4=function(X,Y){return X.__v.__b-Y.__v.__b},T0.__r=0,X4=Math.random().toString(8),C0="__d"+X4,U0="__a"+X4,j4=/(PointerCapture)$|Capture$/i,K4=0,Y4=T4(!1),Z4=T4(!0),R4=0;var N0,T,L4,f4,D0=0,r4=[],b=P,a4=b.__b,c4=b.__r,l4=b.diffed,i4=b.__c,s4=b.unmount,o4=b.__;function j0(X,Y){b.__h&&b.__h(T,X,D0||Y),D0=0;var Z=T.__H||(T.__H={__:[],__h:[]});return X>=Z.__.length&&Z.__.push({}),Z.__[X]}function p(X){return D0=1,N4(n4,X)}function N4(X,Y,Z){var J=j0(N0++,2);if(J.t=X,!J.__c&&(J.__=[Z?Z(Y):n4(void 0,Y),function(z){var G=J.__N?J.__N[0]:J.__[0],L=J.t(G,z);G!==L&&(J.__N=[L,J.__[1]],J.__c.setState({}))}],J.__c=T,!T.__f)){var q=function(z,G,L){if(!J.__c.__H)return!0;var D=J.__c.__H.__.filter(function(O){return O.__c});if(D.every(function(O){return!O.__N}))return!K||K.call(this,z,G,L);var W=J.__c.props!==z;return D.some(function(O){if(O.__N){var U=O.__[0];O.__=O.__N,O.__N=void 0,U!==O.__[0]&&(W=!0)}}),K&&K.call(this,z,G,L)||W};T.__f=!0;var{shouldComponentUpdate:K,componentWillUpdate:Q}=T;T.componentWillUpdate=function(z,G,L){if(this.__e){var D=K;K=void 0,q(z,G,L),K=D}Q&&Q.call(this,z,G,L)},T.shouldComponentUpdate=q}return J.__N||J.__}function d(X,Y){var Z=j0(N0++,3);!b.__s&&t4(Z.__H,Y)&&(Z.__=X,Z.u=Y,T.__H.__h.push(Z))}function w(X){return D0=5,R0(function(){return{current:X}},[])}function R0(X,Y){var Z=j0(N0++,7);return t4(Z.__H,Y)&&(Z.__=X(),Z.__H=Y,Z.__h=X),Z.__}function j(X,Y){return D0=8,R0(function(){return X},Y)}function P0(X){var Y=T.context[X.__c],Z=j0(N0++,9);return Z.c=X,Y?(Z.__==null&&(Z.__=!0,Y.sub(T)),Y.props.value):X.__}function h5(){for(var X;X=r4.shift();){var Y=X.__H;if(X.__P&&Y)try{Y.__h.some(v0),Y.__h.some(z4),Y.__h=[]}catch(Z){Y.__h=[],b.__e(Z,X.__v)}}}b.__b=function(X){T=null,a4&&a4(X)},b.__=function(X,Y){X&&Y.__k&&Y.__k.__m&&(X.__m=Y.__k.__m),o4&&o4(X,Y)},b.__r=function(X){c4&&c4(X),N0=0;var Y=(T=X.__c).__H;Y&&(L4===T?(Y.__h=[],T.__h=[],Y.__.some(function(Z){Z.__N&&(Z.__=Z.__N),Z.u=Z.__N=void 0})):(Y.__h.some(v0),Y.__h.some(z4),Y.__h=[],N0=0)),L4=T},b.diffed=function(X){l4&&l4(X);var Y=X.__c;Y&&Y.__H&&(Y.__H.__h.length&&(r4.push(Y)!==1&&f4===b.requestAnimationFrame||((f4=b.requestAnimationFrame)||f5)(h5)),Y.__H.__.some(function(Z){Z.u&&(Z.__H=Z.u),Z.u=void 0})),L4=T=null},b.__c=function(X,Y){Y.some(function(Z){try{Z.__h.some(v0),Z.__h=Z.__h.filter(function(J){return!J.__||z4(J)})}catch(J){Y.some(function(q){q.__h&&(q.__h=[])}),Y=[],b.__e(J,Z.__v)}}),i4&&i4(X,Y)},b.unmount=function(X){s4&&s4(X);var Y,Z=X.__c;Z&&Z.__H&&(Z.__H.__.some(function(J){try{v0(J)}catch(q){Y=q}}),Z.__H=void 0,Y&&b.__e(Y,Z.__v))};var u4=typeof requestAnimationFrame=="function";function f5(X){var Y,Z=function(){clearTimeout(J),u4&&cancelAnimationFrame(Y),setTimeout(X)},J=setTimeout(Z,35);u4&&(Y=requestAnimationFrame(Z))}function v0(X){var Y=T,Z=X.__c;typeof Z=="function"&&(X.__c=void 0,Z()),T=Y}function z4(X){var Y=T;X.__c=X.__(),T=Y}function t4(X,Y){return!X||X.length!==Y.length||Y.some(function(Z,J){return Z!==X[J]})}function n4(X,Y){return typeof Y=="function"?Y(X):Y}function u5(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function e4(X,Y){for(var Z in X)if(Z!=="__source"&&!(Z in Y))return!0;for(var J in Y)if(J!=="__source"&&X[J]!==Y[J])return!0;return!1}function X5(X,Y){this.props=X,this.context=Y}(X5.prototype=new g).isPureReactComponent=!0,X5.prototype.shouldComponentUpdate=function(X,Y){return e4(this.props,X)||e4(this.state,Y)};var Y5=P.__b;P.__b=function(X){X.type&&X.type.__f&&X.ref&&(X.props.ref=X.ref,X.ref=null),Y5&&Y5(X)};var r5=P.__e;P.__e=function(X,Y,Z,J){if(X.then){for(var q,K=Y;K=K.__;)if((q=K.__c)&&q.__c)return Y.__e==null&&(Y.__e=Z.__e,Y.__k=Z.__k),q.__c(X,Y)}r5(X,Y,Z,J)};var Z5=P.unmount;function W5(X,Y,Z){return X&&(X.__c&&X.__c.__H&&(X.__c.__H.__.forEach(function(J){typeof J.__c=="function"&&J.__c()}),X.__c.__H=null),(X=u5({},X)).__c!=null&&(X.__c.__P===Z&&(X.__c.__P=Y),X.__c.__e=!0,X.__c=null),X.__k=X.__k&&X.__k.map(function(J){return W5(J,Y,Z)})),X}function L5(X,Y,Z){return X&&Z&&(X.__v=null,X.__k=X.__k&&X.__k.map(function(J){return L5(J,Y,Z)}),X.__c&&X.__c.__P===Y&&(X.__e&&Z.appendChild(X.__e),X.__c.__e=!0,X.__c.__P=Z)),X}function G4(){this.__u=0,this.o=null,this.__b=null}function z5(X){var Y=X.__&&X.__.__c;return Y&&Y.__a&&Y.__a(X)}function y0(){this.i=null,this.l=null}P.unmount=function(X){var Y=X.__c;Y&&(Y.__z=!0),Y&&Y.__R&&Y.__R(),Y&&32&X.__u&&(X.type=null),Z5&&Z5(X)},(G4.prototype=new g).__c=function(X,Y){var Z=Y.__c,J=this;J.o==null&&(J.o=[]),J.o.push(Z);var q=z5(J.__v),K=!1,Q=function(){K||J.__z||(K=!0,Z.__R=null,q?q(G):G())};Z.__R=Q;var z=Z.__P;Z.__P=null;var G=function(){if(!--J.__u){if(J.state.__a){var L=J.state.__a;J.__v.__k[0]=L5(L,L.__c.__P,L.__c.__O)}var D;for(J.setState({__a:J.__b=null});D=J.o.pop();)D.__P=z,D.forceUpdate()}};J.__u++||32&Y.__u||J.setState({__a:J.__b=J.__v.__k[0]}),X.then(Q,Q)},G4.prototype.componentWillUnmount=function(){this.o=[]},G4.prototype.render=function(X,Y){if(this.__b){if(this.__v.__k){var Z=document.createElement("div"),J=this.__v.__k[0].__c;this.__v.__k[0]=W5(this.__b,Z,J.__O=J.__P)}this.__b=null}var q=Y.__a&&Y0(x,null,X.fallback);return q&&(q.__u&=-33),[Y0(x,null,Y.__a?null:X.children),q]};var J5=function(X,Y,Z){if(++Z[1]===Z[0]&&X.l.delete(Y),X.props.revealOrder&&(X.props.revealOrder[0]!=="t"||!X.l.size))for(Z=X.i;Z;){for(;Z.length>3;)Z.pop()();if(Z[1]<Z[0])break;X.i=Z=Z[2]}};(y0.prototype=new g).__a=function(X){var Y=this,Z=z5(Y.__v),J=Y.l.get(X);return J[0]++,function(q){var K=function(){Y.props.revealOrder?(J.push(q),J5(Y,X,J)):q()};Z?Z(K):K()}},y0.prototype.render=function(X){this.i=null,this.l=new Map;var Y=Z0(X.children);X.revealOrder&&X.revealOrder[0]==="b"&&Y.reverse();for(var Z=Y.length;Z--;)this.l.set(Y[Z],this.i=[1,0,this.i]);return X.children},y0.prototype.componentDidUpdate=y0.prototype.componentDidMount=function(){var X=this;this.l.forEach(function(Y,Z){J5(X,Z,Y)})};var t5=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,n5=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,e5=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,X6=/[A-Z0-9]/g,Y6=typeof document<"u",Z6=function(X){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(X)};function N5(X,Y,Z){return Y.__k==null&&(Y.textContent=""),p0(X,Y),typeof Z=="function"&&Z(),X?X.__c:null}g.prototype.isReactComponent=!0,["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(X){Object.defineProperty(g.prototype,X,{configurable:!0,get:function(){return this["UNSAFE_"+X]},set:function(Y){Object.defineProperty(this,X,{configurable:!0,writable:!0,value:Y})}})});var q5=P.event;P.event=function(X){return q5&&(X=q5(X)),X.persist=function(){},X.isPropagationStopped=function(){return this.cancelBubble},X.isDefaultPrevented=function(){return this.defaultPrevented},X.nativeEvent=X};var G5,J6={configurable:!0,get:function(){return this.class}},K5=P.vnode;P.vnode=function(X){typeof X.type=="string"&&function(Y){var{props:Z,type:J}=Y,q={},K=J.indexOf("-")==-1;for(var Q in Z){var z=Z[Q];if(!(Q==="value"&&("defaultValue"in Z)&&z==null||Y6&&Q==="children"&&J==="noscript"||Q==="class"||Q==="className")){var G=Q.toLowerCase();Q==="defaultValue"&&"value"in Z&&Z.value==null?Q="value":Q==="download"&&z===!0?z="":G==="translate"&&z==="no"?z=!1:G[0]==="o"&&G[1]==="n"?G==="ondoubleclick"?Q="ondblclick":G!=="onchange"||J!=="input"&&J!=="textarea"||Z6(Z.type)?G==="onfocus"?Q="onfocusin":G==="onblur"?Q="onfocusout":e5.test(Q)&&(Q=G):G=Q="oninput":K&&n5.test(Q)?Q=Q.replace(X6,"-$&").toLowerCase():z===null&&(z=void 0),G==="oninput"&&q[Q=G]&&(Q="oninputCapture"),q[Q]=z}}J=="select"&&(q.multiple&&Array.isArray(q.value)&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.value.indexOf(L.props.value)!=-1})),q.defaultValue!=null&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.multiple?q.defaultValue.indexOf(L.props.value)!=-1:q.defaultValue==L.props.value}))),Z.class&&!Z.className?(q.class=Z.class,Object.defineProperty(q,"className",J6)):Z.className&&(q.class=q.className=Z.className),Y.props=q}(X),X.$$typeof=t5,K5&&K5(X)};var Q5=P.__r;P.__r=function(X){Q5&&Q5(X),G5=X.__c};var $5=P.diffed;P.diffed=function(X){$5&&$5(X);var{props:Y,__e:Z}=X;Z!=null&&X.type==="textarea"&&"value"in Y&&Y.value!==Z.value&&(Z.value=Y.value==null?"":Y.value),G5=null};function V5(X){return!!X.__k&&(p0(null,X),!0)}function H5(X){return{render:function(Y){N5(Y,X)},unmount:function(){V5(X)}}}function I5(X,Y){for(var Z in Y)X[Z]=Y[Z];return X}function O5(X,Y){for(var Z in X)if(Z!=="__source"&&!(Z in Y))return!0;for(var J in Y)if(J!=="__source"&&X[J]!==Y[J])return!0;return!1}function U5(X,Y){this.props=X,this.context=Y}(U5.prototype=new g).isPureReactComponent=!0,U5.prototype.shouldComponentUpdate=function(X,Y){return O5(this.props,X)||O5(this.state,Y)};var A5=P.__b;P.__b=function(X){X.type&&X.type.__f&&X.ref&&(X.props.ref=X.ref,X.ref=null),A5&&A5(X)};var q6=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911;function G0(X){function Y(Z){var J=I5({},Z);return delete J.ref,X(J,Z.ref||null)}return Y.$$typeof=q6,Y.render=X,Y.prototype.isReactComponent=Y.__f=!0,Y.displayName="ForwardRef("+(X.displayName||X.name)+")",Y}var K6=P.__e;P.__e=function(X,Y,Z,J){if(X.then){for(var q,K=Y;K=K.__;)if((q=K.__c)&&q.__c)return Y.__e==null&&(Y.__e=Z.__e,Y.__k=Z.__k),q.__c(X,Y)}K6(X,Y,Z,J)};var D5=P.unmount;function M5(X,Y,Z){return X&&(X.__c&&X.__c.__H&&(X.__c.__H.__.forEach(function(J){typeof J.__c=="function"&&J.__c()}),X.__c.__H=null),(X=I5({},X)).__c!=null&&(X.__c.__P===Z&&(X.__c.__P=Y),X.__c.__e=!0,X.__c=null),X.__k=X.__k&&X.__k.map(function(J){return M5(J,Y,Z)})),X}function C5(X,Y,Z){return X&&Z&&(X.__v=null,X.__k=X.__k&&X.__k.map(function(J){return C5(J,Y,Z)}),X.__c&&X.__c.__P===Y&&(X.__e&&Z.appendChild(X.__e),X.__c.__e=!0,X.__c.__P=Z)),X}function H4(){this.__u=0,this.o=null,this.__b=null}function E5(X){var Y=X.__&&X.__.__c;return Y&&Y.__a&&Y.__a(X)}function g0(){this.i=null,this.l=null}P.unmount=function(X){var Y=X.__c;Y&&(Y.__z=!0),Y&&Y.__R&&Y.__R(),Y&&32&X.__u&&(X.type=null),D5&&D5(X)},(H4.prototype=new g).__c=function(X,Y){var Z=Y.__c,J=this;J.o==null&&(J.o=[]),J.o.push(Z);var q=E5(J.__v),K=!1,Q=function(){K||J.__z||(K=!0,Z.__R=null,q?q(G):G())};Z.__R=Q;var z=Z.__P;Z.__P=null;var G=function(){if(!--J.__u){if(J.state.__a){var L=J.state.__a;J.__v.__k[0]=C5(L,L.__c.__P,L.__c.__O)}var D;for(J.setState({__a:J.__b=null});D=J.o.pop();)D.__P=z,D.forceUpdate()}};J.__u++||32&Y.__u||J.setState({__a:J.__b=J.__v.__k[0]}),X.then(Q,Q)},H4.prototype.componentWillUnmount=function(){this.o=[]},H4.prototype.render=function(X,Y){if(this.__b){if(this.__v.__k){var Z=document.createElement("div"),J=this.__v.__k[0].__c;this.__v.__k[0]=M5(this.__b,Z,J.__O=J.__P)}this.__b=null}var q=Y.__a&&Y0(x,null,X.fallback);return q&&(q.__u&=-33),[Y0(x,null,Y.__a?null:X.children),q]};var P5=function(X,Y,Z){if(++Z[1]===Z[0]&&X.l.delete(Y),X.props.revealOrder&&(X.props.revealOrder[0]!=="t"||!X.l.size))for(Z=X.i;Z;){for(;Z.length>3;)Z.pop()();if(Z[1]<Z[0])break;X.i=Z=Z[2]}};(g0.prototype=new g).__a=function(X){var Y=this,Z=E5(Y.__v),J=Y.l.get(X);return J[0]++,function(q){var K=function(){Y.props.revealOrder?(J.push(q),P5(Y,X,J)):q()};Z?Z(K):K()}},g0.prototype.render=function(X){this.i=null,this.l=new Map;var Y=Z0(X.children);X.revealOrder&&X.revealOrder[0]==="b"&&Y.reverse();for(var Z=Y.length;Z--;)this.l.set(Y[Z],this.i=[1,0,this.i]);return X.children},g0.prototype.componentDidUpdate=g0.prototype.componentDidMount=function(){var X=this;this.l.forEach(function(Y,Z){P5(X,Z,Y)})};var Q6=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,$6=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,W6=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,L6=/[A-Z0-9]/g,z6=typeof document<"u",N6=function(X){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(X)};g.prototype.isReactComponent=!0,["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(X){Object.defineProperty(g.prototype,X,{configurable:!0,get:function(){return this["UNSAFE_"+X]},set:function(Y){Object.defineProperty(this,X,{configurable:!0,writable:!0,value:Y})}})});var B5=P.event;P.event=function(X){return B5&&(X=B5(X)),X.persist=function(){},X.isPropagationStopped=function(){return this.cancelBubble},X.isDefaultPrevented=function(){return this.defaultPrevented},X.nativeEvent=X};var w5,G6={configurable:!0,get:function(){return this.class}},_5=P.vnode;P.vnode=function(X){typeof X.type=="string"&&function(Y){var{props:Z,type:J}=Y,q={},K=J.indexOf("-")==-1;for(var Q in Z){var z=Z[Q];if(!(Q==="value"&&("defaultValue"in Z)&&z==null||z6&&Q==="children"&&J==="noscript"||Q==="class"||Q==="className")){var G=Q.toLowerCase();Q==="defaultValue"&&"value"in Z&&Z.value==null?Q="value":Q==="download"&&z===!0?z="":G==="translate"&&z==="no"?z=!1:G[0]==="o"&&G[1]==="n"?G==="ondoubleclick"?Q="ondblclick":G!=="onchange"||J!=="input"&&J!=="textarea"||N6(Z.type)?G==="onfocus"?Q="onfocusin":G==="onblur"?Q="onfocusout":W6.test(Q)&&(Q=G):G=Q="oninput":K&&$6.test(Q)?Q=Q.replace(L6,"-$&").toLowerCase():z===null&&(z=void 0),G==="oninput"&&q[Q=G]&&(Q="oninputCapture"),q[Q]=z}}J=="select"&&(q.multiple&&Array.isArray(q.value)&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.value.indexOf(L.props.value)!=-1})),q.defaultValue!=null&&(q.value=Z0(Z.children).forEach(function(L){L.props.selected=q.multiple?q.defaultValue.indexOf(L.props.value)!=-1:q.defaultValue==L.props.value}))),Z.class&&!Z.className?(q.class=Z.class,Object.defineProperty(q,"className",G6)):Z.className&&(q.class=q.className=Z.className),Y.props=q}(X),X.$$typeof=Q6,_5&&_5(X)};var F5=P.__r;P.__r=function(X){F5&&F5(X),w5=X.__c};var k5=P.diffed;P.diffed=function(X){k5&&k5(X);var{props:Y,__e:Z}=X;Z!=null&&X.type==="textarea"&&"value"in Y&&Y.value!==Z.value&&(Z.value=Y.value==null?"":Y.value),w5=null};var V6=0;function $(X,Y,Z,J,q,K){Y||(Y={});var Q,z,G=Y;if("ref"in G)for(z in G={},Y)z=="ref"?Q=Y[z]:G[z]=Y[z];var L={type:X,props:G,key:Z,ref:Q,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--V6,__i:-1,__u:0,__source:q,__self:K};if(typeof X=="function"&&(Q=X.defaultProps))for(z in Q)G[z]===void 0&&(G[z]=Q[z]);return P.vnode&&P.vnode(L),L}var O4=`url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Ccircle cx='10' cy='10' r='9' fill='rgba(255,255,255,0.4)' stroke='rgba(255,255,255,0.7)' stroke-width='1'/%3E%3C/svg%3E") 10 10, pointer`,H6=3,O6=4,U6=5;function x0({url:X,wsUrl:Y,style:Z,imageStyle:J,className:q,onHomePress:K,onStreamTouch:Q,onStreamMultiTouch:z,onStreamButton:G,subscribeFrame:L,streamFrame:D,streamConfig:W,hideControls:O,onStreamingChange:U,connectionQuality:k}){let _=!!Q,C=w(null),M=w(null),F=w(null),[E,I]=p(!1),[v,r]=p(null),[f,i]=p(null),y=w(null),[m,c0]=p(null);d(()=>{let V=y.current;if(!V||typeof ResizeObserver>"u")return;let H=new ResizeObserver((N)=>{let A=N[0]?.contentRect;if(A)c0({width:A.width,height:A.height})});return H.observe(V),()=>H.disconnect()},[]);let[D4,P4]=p(0),W0=w(0),[p5,l0]=p(!1),t=w(null);d(()=>{if(k==="poor"){if(l0(!0),t.current)clearTimeout(t.current);t.current=setTimeout(()=>{l0(!1),t.current=null},3000)}else if(l0(!1),t.current)clearTimeout(t.current),t.current=null;return()=>{if(t.current)clearTimeout(t.current)}},[k]);let i0=`${X}/stream.mjpeg`,B4=w(U);B4.current=U,d(()=>{B4.current?.(E)},[E]),d(()=>{if(_&&W)i(W)},[_,W]);let _4=w(!1);_4.current=E;let s0=w(null);d(()=>{if(!_||!L)return;return L((V)=>{W0.current++;let H=M.current;if(H){if(s0.current)URL.revokeObjectURL(s0.current);s0.current=V,H.src=V}if(!_4.current)console.log("[serve-sim] first frame received, rendering"),I(!0),r(null)})},[_,L]);let c=j((V)=>{if(_){Q?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify(V)),A=new Uint8Array(1+N.length);A[0]=H6,A.set(N,1),H.send(A)},[_,Q]),o0=j((V)=>{if(_){G?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify({button:V})),A=new Uint8Array(1+N.length);A[0]=O6,A.set(N,1),H.send(A)},[_,G]),n=j((V)=>{if(_){z?.(V);return}let H=F.current;if(!H||H.readyState!==WebSocket.OPEN)return;let N=new TextEncoder().encode(JSON.stringify(V)),A=new Uint8Array(1+N.length);A[0]=U6,A.set(N,1),H.send(A)},[_,z]);d(()=>{if(_)return;fetch(`${X}/config`).then((B)=>B.json()).then((B)=>{if(B.width>0&&B.height>0)i(B)}).catch(()=>{});let V=Y??X.replace(/^http/,"ws")+"/ws",H=new WebSocket(V);H.binaryType="arraybuffer",F.current=H,H.onopen=()=>{I(!0),r(null)},H.onclose=()=>{I(!1)},H.onerror=()=>{r("WebSocket connection failed"),I(!1)};let N=new AbortController,A=setInterval(()=>{P4(W0.current),W0.current=0},1000);return(async()=>{try{let S=(await fetch(i0,{signal:N.signal})).body?.getReader();if(!S)return;let h=new TextEncoder().encode("--frame");while(!0){let{done:l,value:u}=await S.read();if(l)break;if(u)for(let e0=0;e0<=u.length-h.length;e0++){let E4=!0;for(let I0=0;I0<h.length;I0++)if(u[e0+I0]!==h[I0]){E4=!1;break}if(E4)W0.current++}}}catch{}})(),()=>{N.abort(),clearInterval(A),H.close(),F.current=null}},[X,i0,_]),d(()=>{if(!_)return;let V=setInterval(()=>{P4(W0.current),W0.current=0},1000);return()=>clearInterval(V)},[_]);let e=j(()=>{return _?M.current:C.current},[_]),B0=j((V,H)=>{let N=e();if(!N)return;let A=N.getBoundingClientRect(),B=(H.clientX-A.left)/A.width,S=(H.clientY-A.top)/A.height;c({type:V,x:B,y:S})},[c]),Q0=3,a=w(!1),o=w(!1),u0=w(!1),r0=w({dx:0,dy:0}),V0=w(!1),[t0,F4]=p(!1),k4=w({x:0.5,y:0.5}),[q0,s]=p(null);d(()=>{let V=(N)=>{if(N.key==="Alt")F4(!0)},H=(N)=>{if(N.key==="Alt"){if(F4(!1),!o.current)s(null)}};return window.addEventListener("keydown",V),window.addEventListener("keyup",H),()=>{window.removeEventListener("keydown",V),window.removeEventListener("keyup",H)}},[]),d(()=>{if(t0&&!o.current){let V=k4.current;s({x1:V.x,y1:V.y,x2:1-V.x,y2:1-V.y})}else if(!t0&&!o.current)s(null)},[t0]);let _0=w(null),n0=w(!1),H0=w(0),I4=j((V,H)=>{n0.current=!0;let N=_0.current;if(N)cancelAnimationFrame(H0.current),H0.current=requestAnimationFrame(()=>{N.style.left=`${V*100}%`,N.style.top=`${H*100}%`,N.style.display="block"})},[]),M4=j((V,H)=>{if(!n0.current)return;let N=_0.current;if(N)cancelAnimationFrame(H0.current),H0.current=requestAnimationFrame(()=>{N.style.left=`${V*100}%`,N.style.top=`${H*100}%`})},[]),F0=j(()=>{n0.current=!1;let V=_0.current;if(V)cancelAnimationFrame(H0.current),V.style.display="none"},[]),C4=w(0),O0=w(null),v5=j(()=>{let V=Date.now(),H=V-C4.current;if(C4.current=V,H<300){if(O0.current)clearTimeout(O0.current),O0.current=null;if(K)K();else o0("app_switcher")}else O0.current=setTimeout(()=>{if(K)K();else o0("home");O0.current=null},300)},[o0,K]),k0=(()=>{if(!f||!m)return null;if(m.width===0||m.height===0)return null;let V=Math.min(m.width/f.width,m.height/f.height);return{width:f.width*V,height:f.height*V}})();return $("div",{style:{display:"flex",flexDirection:"column",flex:1,...O?{}:{border:"1px solid rgba(255,255,255,0.12)"},overflow:"hidden",minWidth:0,minHeight:0,...Z},className:q,children:[$("div",{ref:y,style:{position:"relative",flex:1,minHeight:0,minWidth:0,display:"flex",alignItems:"center",justifyContent:"center"},children:$("div",{style:{position:"relative",width:k0?`${k0.width}px`:"100%",height:k0?`${k0.height}px`:"100%"},children:[$("img",{ref:C,src:_?void 0:i0,draggable:!1,onLoad:(V)=>{let H=V.currentTarget;if(H.naturalWidth>0&&H.naturalHeight>0)i((N)=>N&&N.width===H.naturalWidth&&N.height===H.naturalHeight?N:{width:H.naturalWidth,height:H.naturalHeight})},style:_?{display:"none"}:{position:"absolute",inset:0,width:"100%",height:"100%",cursor:O4,display:"block",userSelect:"none",WebkitUserSelect:"none",touchAction:"none",...J}}),_&&$("img",{ref:M,draggable:!1,onLoad:(V)=>{let H=V.currentTarget;if(H.naturalWidth>0&&H.naturalHeight>0)i((N)=>N&&N.width===H.naturalWidth&&N.height===H.naturalHeight?N:{width:H.naturalWidth,height:H.naturalHeight})},style:{position:"absolute",inset:0,width:"100%",height:"100%",cursor:O4,display:"block",userSelect:"none",WebkitUserSelect:"none",touchAction:"none",...J}}),$("div",{style:{position:"absolute",inset:0,cursor:O4,touchAction:"none"},onMouseDown:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(V.altKey){o.current=!0,u0.current=V.shiftKey;let S={x1:A,y1:B,x2:1-A,y2:1-B};r0.current={dx:1-A-A,dy:1-B-B},s(S),n({type:"begin",...S});return}if(I4(A,B),B>0.88)a.current=!0,c({type:"begin",x:A,y:B,edge:Q0});else a.current=!1,B0("begin",V)},onMouseMove:(V)=>{let H=e();if(!H)return;let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(k4.current={x:A,y:B},V.buttons===0){if(V.altKey)s({x1:A,y1:B,x2:1-A,y2:1-B});return}if(o.current){let S;if(u0.current){let h=r0.current;S={x1:A,y1:B,x2:A+h.dx,y2:B+h.dy}}else S={x1:A,y1:B,x2:1-A,y2:1-B};s(S),n({type:"move",...S});return}if(M4(A,B),a.current)c({type:"move",x:A,y:B,edge:Q0});else B0("move",V)},onMouseUp:(V)=>{if(o.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;if(u0.current){let S=r0.current;n({type:"end",x1:A,y1:B,x2:A+S.dx,y2:B+S.dy})}else n({type:"end",x1:A,y1:B,x2:1-A,y2:1-B})}if(o.current=!1,!V.altKey)s(null);return}if(F0(),a.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;c({type:"end",x:A,y:B,edge:Q0})}a.current=!1;return}B0("end",V)},onMouseLeave:(V)=>{if(o.current){if(q0)n({type:"end",...q0});o.current=!1,s(null);return}if(F0(),a.current){let H=e();if(H){let N=H.getBoundingClientRect(),A=(V.clientX-N.left)/N.width,B=(V.clientY-N.top)/N.height;c({type:"end",x:A,y:B,edge:Q0})}a.current=!1;return}if(V.buttons>0)B0("end",V);s(null)},onTouchStart:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V.touches.length>=2){F0();let h=V.touches[0],l=V.touches[1],u={x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:(l.clientX-N.left)/N.width,y2:(l.clientY-N.top)/N.height};if(!V0.current&&!a.current)c({type:"end",x:u.x1,y:u.y1});V0.current=!0,o.current=!0,a.current=!1,s(u),n({type:"begin",...u});return}let A=V.touches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(I4(B,S),S>0.88)a.current=!0,c({type:"begin",x:B,y:S,edge:Q0});else a.current=!1,c({type:"begin",x:B,y:S})},onTouchMove:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V0.current&&V.touches.length>=2){let h=V.touches[0],l=V.touches[1],u={x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:(l.clientX-N.left)/N.width,y2:(l.clientY-N.top)/N.height};s(u),n({type:"move",...u});return}let A=V.touches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(M4(B,S),a.current)c({type:"move",x:B,y:S,edge:Q0});else c({type:"move",x:B,y:S})},onTouchEnd:(V)=>{V.preventDefault();let H=e();if(!H)return;let N=H.getBoundingClientRect();if(V0.current){if(V.touches.length<2){let h=V.changedTouches[0],l=q0;if(h&&l)n({type:"end",x1:(h.clientX-N.left)/N.width,y1:(h.clientY-N.top)/N.height,x2:l.x2,y2:l.y2});else if(l)n({type:"end",...l});V0.current=!1,o.current=!1,s(null)}return}let A=V.changedTouches[0];if(!A)return;let B=(A.clientX-N.left)/N.width,S=(A.clientY-N.top)/N.height;if(F0(),a.current)c({type:"end",x:B,y:S,edge:Q0}),a.current=!1;else c({type:"end",x:B,y:S})}}),$("div",{ref:_0,"data-testid":"touch-indicator",style:{position:"absolute",display:"none",width:24,height:24,borderRadius:"50%",background:"rgba(59,130,246,0.5)",boxShadow:"0 0 8px rgba(59,130,246,0.3)",transform:"translate(-50%, -50%)",pointerEvents:"none"}}),q0&&$(x,{children:[$("div",{"data-testid":"finger-dot",style:b5(q0.x1,q0.y1)}),$("div",{"data-testid":"finger-dot",style:b5(q0.x2,q0.y2)})]}),!E&&!v&&$("div",{style:S5,children:$("span",{style:{color:"#888",fontSize:14},children:"Connecting..."})}),v&&$("div",{style:S5,children:$("span",{style:{color:"#f44",fontSize:14,padding:20,textAlign:"center"},children:v})}),p5&&$("div",{style:A6,children:$("span",{style:{color:"#fbbf24",fontSize:13,fontFamily:"monospace"},children:"Slow connection"})})]})}),!O&&$("div",{style:{display:"flex",alignItems:"center",justifyContent:"space-between",padding:"4px 8px",borderTop:"1px solid rgba(255,255,255,0.12)"},children:[$("button",{onClick:v5,style:{background:"none",border:"1px solid rgba(255,255,255,0.2)",color:"#aaa",fontSize:11,fontFamily:"monospace",padding:"2px 10px",cursor:"pointer",borderRadius:4},children:"Home"}),$("span",{style:{color:D4>0?"#4f4":"#888",fontSize:12,fontFamily:"monospace",display:"flex",alignItems:"center",gap:6},children:[k&&$("span",{"data-testid":"quality-dot",style:{width:8,height:8,borderRadius:"50%",display:"inline-block",background:k==="good"?"#4ade80":k==="degraded"?"#facc15":"#ef4444"}}),D4," fps"]})]})]})}var A6={position:"absolute",top:8,left:"50%",transform:"translateX(-50%)",background:"rgba(0,0,0,0.7)",borderRadius:6,padding:"4px 12px",pointerEvents:"none"},S5={position:"absolute",inset:0,display:"flex",alignItems:"center",justifyContent:"center",background:"rgba(0,0,0,0.8)"},T5=20;function b5(X,Y){return{position:"absolute",left:`${X*100}%`,top:`${Y*100}%`,width:T5,height:T5,borderRadius:"50%",background:"rgba(255,255,255,0.4)",border:"1px solid rgba(255,255,255,0.7)",transform:"translate(-50%, -50%)",pointerEvents:"none"}}function d0(X){if(!X)return"iphone";let Y=X.toLowerCase();if(Y.includes("ipad"))return"ipad";if(Y.includes("watch"))return"watch";if(Y.includes("vision"))return"vision";return"iphone"}var R={iphone:{width:427,height:881,bezelX:18,bezelY:18,innerRadius:55},ipad:{width:430,height:605,bezelX:16,bezelY:16,innerRadius:12},watch:{width:274,height:322,bezelX:12,bezelY:12,innerRadius:79},vision:{width:640,height:400,bezelX:12,bezelY:12,innerRadius:32}},U7=R.iphone.width,A7=R.iphone.height,D7=R.iphone.bezelX,P7=R.iphone.bezelY,B7=R.iphone.innerRadius;function U4(X="iphone"){let Y=R[X];return{top:`${Y.bezelY/Y.height*100}%`,left:`${Y.bezelX/Y.width*100}%`,right:`${Y.bezelX/Y.width*100}%`,bottom:`${Y.bezelY/Y.height*100}%`}}function m0(X="iphone"){let Y=R[X],Z=Y.width-2*Y.bezelX,J=Y.height-2*Y.bezelY;return`${Y.innerRadius/Z*100}% / ${Y.innerRadius/J*100}%`}function h0({type:X="iphone",streaming:Y=!1}){switch(X){case"ipad":return $(B6,{streaming:Y});case"watch":return $(_6,{streaming:Y});case"vision":return $(F6,{streaming:Y});default:return $(P6,{streaming:Y})}}function P6({streaming:X=!1}){return $("svg",{viewBox:"0 0 427 881",style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"chrome-filter0",x:"-0.166992",y:"0.166504",width:"427",height:"880.667",filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"effect1_foregroundBlur"})]}),$("filter",{id:"chrome-filter1",x:"6.33236",y:"6.33382",width:"414",height:"868",filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333333",result:"effect1_foregroundBlur"})]})]}),$("rect",{x:"3.83268",y:"3.83366",width:"419",height:"873",rx:"66.1667",stroke:"#454548",strokeWidth:"4.33333"}),$("rect",{x:"0.833333",y:"0.833333",width:"425",height:"879",rx:"69.1667",stroke:"#37373a",strokeWidth:"1.66667"}),$("g",{opacity:"0.9",filter:"url(#chrome-filter0)",children:$("rect",{x:"1.66602",y:"2",width:"423.333",height:"877",rx:"68.6667",stroke:"#454548",strokeWidth:"1.66667"})}),$("g",{opacity:"0.8",filter:"url(#chrome-filter1)",children:$("rect",{x:"7.33268",y:"7.33366",width:"412",height:"866",rx:"62.6667",stroke:"#646464",strokeWidth:"0.666667"})}),$("rect",{x:"151.666",y:"31.667",width:"123.333",height:"36",rx:"18",fill:"black",style:{opacity:X?0:1,transition:"opacity 0.3s ease"}})]})}function B6({streaming:X=!1}){let Y=R.ipad.width,Z=R.ipad.height,J=30,q=26;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"ipad-glow0",x:"0",y:"0",width:Y,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]}),$("filter",{id:"ipad-glow1",x:"5",y:"5",width:Y-10,height:Z-10,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333333",result:"blur"})]})]}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:26,stroke:"#454548",strokeWidth:"4"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:30,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#ipad-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:29,stroke:"#454548",strokeWidth:"1.666"})}),$("g",{opacity:"0.8",filter:"url(#ipad-glow1)",children:$("rect",{x:"6",y:"6",width:Y-12,height:Z-12,rx:24,stroke:"#646464",strokeWidth:"0.666"})}),$("circle",{cx:Y/2,cy:R.ipad.bezelY/2+1,r:"3",fill:"#1a1a1a",style:{opacity:X?0:0.8,transition:"opacity 0.3s ease"}}),$("rect",{x:(Y-120)/2,y:Z-R.ipad.bezelY/2-2.5,width:"120",height:"5",rx:"2.5",fill:"white",style:{opacity:X?0:0.35,mixBlendMode:"difference",transition:"opacity 0.3s ease"}})]})}function _6({streaming:X=!1}){let Y=R.watch.width,Z=R.watch.height,J=88,q=82,K=8,Q=36,z=Z/2-18-16,G=22,L=Z/2-11+16;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%",overflow:"visible"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:$("filter",{id:"watch-glow0",x:"0",y:"0",width:Y+12,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]})}),$("rect",{x:Y-2,y:z,width:8,height:36,rx:"3",fill:"#2a2a2c",stroke:"#454548",strokeWidth:"1"}),$("rect",{x:Y-1,y:L,width:6,height:22,rx:"2.5",fill:"#2a2a2c",stroke:"#454548",strokeWidth:"0.8"}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:82,stroke:"#454548",strokeWidth:"3.5"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:88,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#watch-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:87,stroke:"#454548",strokeWidth:"1.666"})})]})}function F6({streaming:X=!1}){let Y=R.vision.width,Z=R.vision.height,J=40,q=34;return $("svg",{viewBox:`0 0 ${Y} ${Z}`,style:{width:"100%",height:"100%"},fill:"none",xmlns:"http://www.w3.org/2000/svg",children:[$("defs",{children:[$("filter",{id:"vision-glow0",x:"0",y:"0",width:Y,height:Z,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.5",result:"blur"})]}),$("filter",{id:"vision-glow1",x:"5",y:"5",width:Y-10,height:Z-10,filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB",children:[$("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),$("feBlend",{mode:"normal",in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),$("feGaussianBlur",{stdDeviation:"0.333",result:"blur"})]}),$("linearGradient",{id:"vision-glass",x1:"0",y1:"0",x2:"0",y2:"1",children:[$("stop",{offset:"0%",stopColor:"#555558",stopOpacity:"0.3"}),$("stop",{offset:"100%",stopColor:"#3a3a3d",stopOpacity:"0.1"})]})]}),$("rect",{x:"0",y:"0",width:Y,height:Z,rx:40,fill:"url(#vision-glass)"}),$("rect",{x:"3.5",y:"3.5",width:Y-7,height:Z-7,rx:34,stroke:"#454548",strokeWidth:"3"}),$("rect",{x:"0.833",y:"0.833",width:Y-1.666,height:Z-1.666,rx:40,stroke:"#37373a",strokeWidth:"1.666"}),$("g",{opacity:"0.9",filter:"url(#vision-glow0)",children:$("rect",{x:"1.5",y:"1.5",width:Y-3,height:Z-3,rx:39,stroke:"#454548",strokeWidth:"1.666"})}),$("g",{opacity:"0.8",filter:"url(#vision-glow1)",children:$("rect",{x:"6",y:"6",width:Y-12,height:Z-12,rx:32,stroke:"#646464",strokeWidth:"0.666"})}),$("ellipse",{cx:Y/2,cy:Z/2,rx:Y/2-30,ry:Z/2-24,stroke:"#4a4a4d",strokeWidth:"0.5",opacity:"0.3",style:{opacity:X?0:0.3,transition:"opacity 0.3s ease"}})]})}var A4=z0(null);function f0(X){let Y=P0(A4);if(!Y)throw Error(`<SimulatorToolbar.${X}> must be rendered inside <SimulatorToolbar>`);return Y}var M6={display:"flex",flexWrap:"wrap",alignItems:"center",justifyContent:"space-between",gap:"4px 12px",padding:"8px 12px",borderRadius:24,background:"#1c1c1e",border:"1px solid rgba(255,255,255,0.1)",boxShadow:"0 1px 2px rgba(0,0,0,0.2)",minWidth:240,width:"100%"};function C6({exec:X,deviceUdid:Y,deviceName:Z,deviceRuntime:J,streaming:q=!1,disabled:K=!1,children:Q,style:z,...G}){let L=d0(Z),W={exec:X,deviceUdid:Y,deviceName:Z,deviceRuntime:J,deviceType:L,streaming:q,disabled:K||!Y||!q};return $(A4.Provider,{value:W,children:$("div",{"data-simulator-toolbar":!0,style:{...M6,...z},...G,children:Q})})}var E6={display:"flex",flexDirection:"column",alignItems:"flex-start",textAlign:"left",background:"transparent",border:"none",color:"#fff",padding:"2px 4px",margin:"-2px -4px",borderRadius:6,cursor:"pointer",minWidth:0,maxWidth:"100%",lineHeight:1.2,fontFamily:"inherit"},w6=G0(function({name:Y,subtitle:Z,hideChevron:J,style:q,onMouseEnter:K,onMouseLeave:Q,...z},G){let L=f0("Title"),[D,W]=p(!1),O=Y??L.deviceName??"No simulator",U=Z??(L.deviceRuntime?L.deviceRuntime.replace(/\./," "):"—");return $("button",{ref:G,type:"button","data-simulator-toolbar-title":!0,onMouseEnter:(k)=>{W(!0),K?.(k)},onMouseLeave:(k)=>{W(!1),Q?.(k)},style:{...E6,background:D?"rgba(255,255,255,0.1)":"transparent",...q},...z,children:[$("span",{style:{display:"inline-flex",alignItems:"center",gap:4,fontSize:12,fontWeight:600,color:"#fff",maxWidth:"100%",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:[O,!J&&$("svg",{width:"10",height:"10",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2.5",strokeLinecap:"round",strokeLinejoin:"round",style:{color:"rgba(255,255,255,0.6)",flexShrink:0},children:$("polyline",{points:"6 9 12 15 18 9"})})]}),$("span",{style:{fontSize:10,color:"rgba(255,255,255,0.5)",maxWidth:"100%",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:U})]})}),S6={display:"flex",alignItems:"center",gap:4,flexShrink:0};function T6({style:X,...Y}){return $("div",{style:{...S6,...X},...Y})}var b6={background:"transparent",border:"none",padding:6,borderRadius:6,cursor:"pointer",display:"inline-flex",alignItems:"center",justifyContent:"center",color:"rgba(255,255,255,0.8)",transition:"background-color 0.15s, color 0.15s"},a0=G0(function({forceDisabled:Y,style:Z,disabled:J,onMouseEnter:q,onMouseLeave:K,children:Q,...z},G){let L=P0(A4),D=J||Y||L?.disabled,[W,O]=p(!1);return $("button",{ref:G,type:"button",disabled:D,onMouseEnter:(U)=>{O(!0),q?.(U)},onMouseLeave:(U)=>{O(!1),K?.(U)},style:{...b6,color:D?"rgba(255,255,255,0.25)":"rgba(255,255,255,0.8)",background:W&&!D?"rgba(255,255,255,0.1)":"transparent",cursor:D?"not-allowed":"pointer",...Z},...z,children:Q})});function p6(){return['tell application "System Events" to tell process "Simulator" to set frontmost to true','tell application "System Events" to tell process "Simulator" to perform action "AXRaise" of (first window whose name contains "watchOS")','tell application "System Events" to tell process "Simulator" to click menu item "Home" of menu "Device" of menu bar item "Device" of menu bar 1'].map((Y)=>`-e '${Y}'`).reduce((Y,Z)=>`${Y} ${Z}`,"osascript")}var v6=$("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",children:$("path",{d:"M3 10.5 12 3l9 7.5V20a1 1 0 0 1-1 1h-5v-7h-6v7H4a1 1 0 0 1-1-1z"})}),j6=$("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",children:[$("path",{d:"M14.5 4h-5L7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3z"}),$("circle",{cx:"12",cy:"13",r:"4"})]}),R6=$("svg",{width:"18",height:"18",viewBox:"0 0 12 13",fill:"currentColor",xmlns:"http://www.w3.org/2000/svg",children:$("path",{d:"M10.2305 12.8077H4.42383C3.92383 12.8077 3.54688 12.6846 3.29297 12.4385C3.04297 12.1963 2.91797 11.8194 2.91797 11.3077V5.51274C2.91797 4.99711 3.04297 4.61821 3.29297 4.37602C3.54688 4.12993 3.92383 4.00688 4.42383 4.00688H10.2305C10.7344 4.00688 11.1113 4.12993 11.3613 4.37602C11.6113 4.61821 11.7363 4.99711 11.7363 5.51274V11.3077C11.7363 11.8194 11.6113 12.1963 11.3613 12.4385C11.1113 12.6846 10.7344 12.8077 10.2305 12.8077ZM10.2129 11.8643C10.416 11.8643 10.5625 11.8194 10.6523 11.7295C10.7461 11.6436 10.793 11.4971 10.793 11.2901V5.52446C10.793 5.31743 10.7461 5.17094 10.6523 5.08501C10.5625 4.99516 10.416 4.95024 10.2129 4.95024H4.44141C4.24219 4.95024 4.0957 4.99516 4.00195 5.08501C3.9082 5.17094 3.86133 5.31743 3.86133 5.52446V11.2901C3.86133 11.4971 3.9082 11.6436 4.00195 11.7295C4.0957 11.8194 4.24219 11.8643 4.44141 11.8643H10.2129ZM2.91797 2.58305V0.415083C2.91797 0.20024 2.98633 0.0693803 3.12305 0.0225053C3.25977 -0.0282759 3.41016 0.00688033 3.57422 0.127974L5.05078 1.21196C5.17578 1.30571 5.23828 1.40141 5.23828 1.49907C5.23828 1.59672 5.17578 1.69243 5.05078 1.78618L3.57422 2.8643C3.41016 2.9854 3.25977 3.02251 3.12305 2.97563C2.98633 2.92485 2.91797 2.79399 2.91797 2.58305ZM3.5332 1.15336C3.62695 1.15336 3.70703 1.18657 3.77344 1.25297C3.84375 1.31938 3.87891 1.39751 3.87891 1.48735C3.87891 1.5811 3.84375 1.66313 3.77344 1.73344C3.70703 1.79985 3.62695 1.83305 3.5332 1.83305H2.80664C2.38086 1.83305 2.01172 1.92485 1.69922 2.10844C1.39062 2.28813 1.15234 2.53813 0.984375 2.85844C0.816406 3.17876 0.732422 3.54594 0.732422 3.96001V4.83891C0.732422 4.93657 0.697266 5.02251 0.626953 5.09672C0.552734 5.16704 0.464844 5.20219 0.363281 5.20219C0.265625 5.20219 0.181641 5.16704 0.111328 5.09672C0.0371094 5.02251 0 4.93657 0 4.83891V3.96001C0 3.40141 0.117188 2.91118 0.351562 2.4893C0.582031 2.06743 0.908203 1.7393 1.33008 1.50493C1.74805 1.27055 2.23828 1.15336 2.80078 1.15336H3.5332Z"})}),y6=G0(function({onClick:Y,...Z},J){let q=f0("HomeButton");return $(a0,{ref:J,"aria-label":"Home",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceType==="watch")q.exec(p6());else q.exec("serve-sim button home")},...Z,children:v6})}),g6=G0(function({onClick:Y,...Z},J){let q=f0("ScreenshotButton");return $(a0,{ref:J,"aria-label":"Screenshot",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceUdid)q.exec(`xcrun simctl io ${q.deviceUdid} screenshot ~/Desktop/hatch-screenshot-$(date +%s).png`)},...Z,children:j6})}),x6=G0(function({onClick:Y,...Z},J){let q=f0("RotateButton");return $(a0,{ref:J,"aria-label":"Rotate device",onClick:(K)=>{if(Y?.(K),K.defaultPrevented)return;if(q.deviceUdid)q.exec(`osascript -e 'tell application "Simulator" to activate' -e 'tell application "System Events" to key code 124 using {command down}'`)},...Z,children:R6})}),$0=C6;$0.Title=w6;$0.Actions=T6;$0.Button=a0;$0.HomeButton=y6;$0.ScreenshotButton=g6;$0.RotateButton=x6;function d6(X){let[Y,Z]=p(null),J=w(new Set),[q,K]=p(null),Q=j((z)=>{return J.current.add(z),()=>{J.current.delete(z)}},[]);return d(()=>{if(!X)return;let z=new AbortController,G=X.replace(/\/stream\.mjpeg$/,"");return fetch(`${G}/config`,{signal:z.signal}).then((L)=>L.json()).then((L)=>{if(L.width>0&&L.height>0)Z(L)}).catch(()=>{}),(async()=>{try{let D=(await fetch(X,{signal:z.signal})).body?.getReader();if(!D)return;let W=new Uint8Array(0);while(!0){let{done:O,value:U}=await D.read();if(O)break;let k=new Uint8Array(W.length+U.length);k.set(W),k.set(U,W.length),W=k;while(!0){let _=-1;for(let I=0;I<W.length-1;I++)if(W[I]===255&&W[I+1]===216){_=I;break}if(_===-1)break;let C=-1;for(let I=_+2;I<W.length-1;I++)if(W[I]===255&&W[I+1]===217){C=I+2;break}if(C===-1)break;let M=W.slice(_,C);W=W.slice(C);let F=new Blob([M],{type:"image/jpeg"}),E=URL.createObjectURL(F);K(E);for(let I of J.current)I(E)}}}catch{}})(),()=>z.abort()},[X]),{subscribeFrame:Q,frame:q,config:Y}}function m6(){let X=window.__SIM_PREVIEW__,[Y,Z]=p(!1);if(d(()=>{if(!X?.logsEndpoint)return;let O=new EventSource(X.logsEndpoint),U=new Map,k=["#8be9fd","#50fa7b","#ffb86c","#ff79c6","#bd93f9","#f1fa8c","#6272a4","#ff5555","#69ff94","#d6acff","#ffffa5","#a4ffff","#ff6e6e","#caa9fa","#5af78e"];function _(F){let E=U.get(F);if(!E){let I=0;for(let v=0;v<F.length;v++)I=(I<<5)-I+F.charCodeAt(v)|0;E=k[Math.abs(I)%k.length],U.set(F,E)}return E}let C="",M=!1;return O.onmessage=(F)=>{try{let E=JSON.parse(F.data),I=E.processImagePath?.split("/").pop()??E.senderImagePath?.split("/").pop()??"",v=E.subsystem??"",r=E.category??"",f=E.eventMessage??"";if(!f)return;if(I!==C){if(M)console.groupEnd();let c0=_(I);console.groupCollapsed(`%c${I}${v?` %c${v}${r?":"+r:""}`:""}`,`color:${c0};font-weight:bold`,...v?["color:#888;font-weight:normal"]:[]),M=!0,C=I}let i=(E.messageType??"").toLowerCase(),y=v&&I===C?`%c${r||v}%c `:"",m=y?["color:#888;font-style:italic","color:inherit"]:[];if(i==="fault"||i==="error")console.log(`${y}%c${f}`,...m,"color:#ff5555");else if(i==="debug")console.log(`${y}%c${f}`,...m,"color:#6272a4");else console.log(`${y}%c${f}`,...m,"color:inherit")}catch{}},()=>{if(M)console.groupEnd();O.close()}},[X?.logsEndpoint]),!X)return $("div",{style:J0.page,children:$("div",{style:J0.empty,children:[$("h1",{style:J0.emptyTitle,children:"No serve-sim stream running"}),$("p",{style:J0.emptyHint,children:["Boot an iOS simulator and start a Hatch stream with"," ",$("code",{style:J0.code,children:"bunx serve-sim --detach"}),", then reload."]})]})});let J=R.iphone,q=U4("iphone"),K=m0("iphone"),Q=d6(X.streamUrl),z=w(null);d(()=>{let O=new WebSocket(X.wsUrl);return O.binaryType="arraybuffer",z.current=O,()=>{O.close(),z.current=null}},[X.wsUrl]);let G=j((O,U)=>{let k=z.current;if(!k||k.readyState!==WebSocket.OPEN)return;let _=new TextEncoder().encode(JSON.stringify(U)),C=new Uint8Array(1+_.length);C[0]=O,C.set(_,1),k.send(C)},[]),L=j((O)=>G(3,O),[G]),D=j((O)=>G(5,O),[G]),W=j((O)=>G(4,{button:O}),[G]);return $("div",{style:J0.page,children:[$("div",{style:{position:"relative",maxWidth:320,width:"100%",aspectRatio:`${J.width} / ${J.height}`},children:[$("div",{style:{position:"absolute",...q},children:$(x0,{url:X.url,style:{width:"100%",height:"100%",border:"none"},imageStyle:{borderRadius:K,cornerShape:"superellipse(1.3)"},hideControls:!0,onStreamingChange:Z,onStreamTouch:L,onStreamMultiTouch:D,onStreamButton:W,subscribeFrame:Q.subscribeFrame,streamFrame:Q.frame,streamConfig:Q.config})}),$("div",{style:{position:"absolute",inset:0,pointerEvents:"none",zIndex:10},children:$(h0,{type:"iphone",streaming:Y})})]}),$("div",{style:J0.bar,children:$("span",{style:{...J0.live,color:Y?"#4ade80":"#666"},children:[$("span",{style:{...J0.dot,background:Y?"#4ade80":"#666"}}),Y?"live":"connecting"]})})]})}var J0={page:{display:"flex",flexDirection:"column",alignItems:"center",justifyContent:"center",height:"100vh",background:"#0a0a0a",padding:24,gap:12,fontFamily:"-apple-system, system-ui, sans-serif"},bar:{display:"flex",alignItems:"center",gap:10,fontSize:12,fontFamily:"ui-monospace, monospace",color:"#666"},live:{display:"flex",alignItems:"center",gap:5,transition:"color 0.3s"},dot:{width:6,height:6,borderRadius:"50%",transition:"background 0.3s"},empty:{display:"flex",flexDirection:"column",alignItems:"center",gap:12,textAlign:"center"},emptyTitle:{fontSize:18,margin:0,color:"#eee"},emptyHint:{color:"#888",fontSize:14,maxWidth:480},code:{background:"#222",padding:"2px 6px",borderRadius:4,fontSize:13}};H5(document.getElementById("root")).render($(m6,{}));
</script>
</body></html>","base64").toString("utf-8");return V}function ge(e){let _=(e?.basePath??"/.sim").replace(/\/+$/,"");return(t,C,S)=>{let A=t.url??"";if(A===_||A===_+"/"){let i=N()[0]??null,r=le();if(i){let R=`<script>window.__SIM_PREVIEW__=${JSON.stringify({...i,logsEndpoint:_+"/logs"})}</script>`;r=r.replace("<!--__SIM_PREVIEW_CONFIG__-->",R)}C.writeHead(200,{"Content-Type":"text/html; charset=utf-8","Cache-Control":"no-store"}),C.end(r);return}if(A===_+"/api"){let B=N();C.writeHead(200,{"Content-Type":"application/json","Cache-Control":"no-store"}),C.end(JSON.stringify(B[0]||null));return}if(A===_+"/logs"||A.startsWith(_+"/logs?")){let B=N();if(B.length===0){C.writeHead(404),C.end("No serve-sim device");return}let i=B[0].device;C.writeHead(200,{"Content-Type":"text/event-stream","Cache-Control":"no-cache",Connection:"keep-alive","X-Accel-Buffering":"no"}),C.write(`:
+
+`);let r=Te("xcrun",["simctl","spawn",i,"log","stream","--style","ndjson","--level","info"],{stdio:["ignore","pipe","ignore"]}),s="";r.stdout.on("data",(R)=>{s+=R.toString();let D;while((D=s.indexOf(`
+`))!==-1){let o=s.slice(0,D).trim();if(s=s.slice(D+1),o)C.write("data: "+o+`
+
+`)}}),r.on("close",()=>C.end()),t.on("close",()=>r.kill());return}if(S)S()}}var k,V=null;var K=ce(()=>{k=P(ue(),"serve-sim")});import{execSync as y,spawn as x}from"child_process";import{chmodSync as Fe,existsSync as u,mkdirSync as j,openSync as J,closeSync as Q,readFileSync as v,unlinkSync as L,writeFileSync as Z}from"fs";import{createHash as de}from"crypto";import{homedir as we,networkInterfaces as Oe}from"os";import{join as ve,resolve as W}from"path";import{tmpdir as be}from"os";import{join as g}from"path";import{readdirSync as he}from"fs";var b=g(be(),"serve-sim"),Ze=g(b,"server.json");function F(e){return g(b,`server-${e}.json`)}function d(){try{return he(b).filter((e)=>e.startsWith("server-")&&e.endsWith(".json")).map((e)=>g(b,e))}catch{return[]}}var T="./serve-sim-bin-pwrv9qme.";function q(){if(!u(b))j(b,{recursive:!0})}function p(e){if(e)return M(F(e));for(let _ of d()){let t=M(_);if(t)return t}return null}function M(e){try{if(!u(e))return null;let _=JSON.parse(v(e,"utf-8"));try{return process.kill(_.pid,0),_}catch{return L(e),null}}catch{return null}}function m(){let e=[];for(let _ of d()){let t=M(_);if(t)e.push(t)}return e}function X(e){q(),Z(F(e.device),JSON.stringify(e,null,2))}function l(e){if(e)try{L(F(e))}catch{}else for(let _ of d())try{L(_)}catch{}}function me(){let e=T.startsWith("/$bunfs/");if(!e&&u(T))return T;if(!e){let A=W(import.meta.dir,"../bin/serve-sim-bin");if(u(A))return A;throw Error(`serve-sim-bin not found. Run 'bun run build:swift' first.
+Checked: ${T}, ${A}`)}let _=v(T),t=de("sha256").update(_).digest("hex").slice(0,16),C=W(we(),"Library/Caches/serve-sim");j(C,{recursive:!0});let S=W(C,`serve-sim-bin-${t}`);if(!u(S)){Z(S,_),Fe(S,493);try{y(`codesign -s - -f ${JSON.stringify(S)}`,{stdio:"ignore"})}catch{}}return S}function Y(){try{let e=y("xcrun simctl list devices booted -j",{encoding:"utf-8"}),_=JSON.parse(e);for(let t of Object.values(_.devices))for(let C of t)if(C.state==="Booted")return C.udid}catch{}return null}function z(e){try{let _=y("xcrun simctl list devices -j",{encoding:"utf-8"}),t=JSON.parse(_);for(let C of Object.values(t.devices))for(let S of C)if(S.udid===e)return S.name}catch{}return null}function E(e){if(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i.test(e))return e;try{let _=y("xcrun simctl list devices -j",{encoding:"utf-8"}),t=JSON.parse(_);for(let C of Object.values(t.devices))for(let S of C)if(S.name.toLowerCase()===e.toLowerCase())return S.udid}catch{}console.error(`Could not resolve device: ${e}`),process.exit(1)}function ee(e){try{let _=y("xcrun simctl list devices -j",{encoding:"utf-8"}),t=JSON.parse(_);for(let C of Object.values(t.devices))for(let S of C)if(S.udid===e)return S.state==="Booted"}catch{}return!1}function I(e){try{return process.kill(e,0),!0}catch{return!1}}function G(e){try{process.kill(e,"SIGTERM")}catch{return}let _=Date.now()+500;while(Date.now()<_)try{process.kill(e,0),Bun.sleepSync(25)}catch{return}try{process.kill(e,"SIGKILL")}catch{}let t=Date.now()+500;while(Date.now()<t)try{process.kill(e,0),Bun.sleepSync(25)}catch{return}}function Ee(e){try{let _=y(`lsof -ti tcp:${e}`,{encoding:"utf-8",stdio:"pipe"}).trim();if(!_)return[];let t=process.pid;return _.split(`
+`).map((C)=>parseInt(C,10)).filter((C)=>Number.isFinite(C)&&C!==t)}catch{return[]}}function Ne(e){let _=Ee(e);if(_.length===0)return;console.log(`\x1B[90mPort ${e} busy, killing holder pid(s): ${_.join(", ")}\x1B[0m`);for(let t of _)try{process.kill(t,"SIGKILL")}catch{}Bun.sleepSync(100)}function Ve(e){if(!ee(e))try{y(`xcrun simctl boot ${e}`,{encoding:"utf-8",stdio:"pipe"})}catch(_){let t=(_.stderr??_.message??"").toLowerCase();if(!t.includes("booted")&&!t.includes("current state"))throw Error(`Failed to boot device ${e}: ${_.stderr||_.message}`)}try{y("open -ga Simulator",{encoding:"utf-8",stdio:"pipe",timeout:3000})}catch{}}function We(){let e=Oe();for(let _ of Object.values(e))for(let t of _??[])if(t.family==="IPv4"&&!t.internal)return t.address;return null}async function _e(e){let _=new Set(m().map((t)=>t.port));for(let t=e;t<e+100;t++){if(_.has(t))continue;try{return Bun.serve({port:t,fetch:()=>new Response("ok")}).stop(!0),t}catch{continue}}throw Error(`No available port found in range ${e}-${e+99}`)}async function Le(e){Ve(e);try{y(`xcrun simctl bootstatus ${e} -b`,{encoding:"utf-8",stdio:"pipe",timeout:60000})}catch(_){if(!ee(e))console.error(`Device ${e} failed to reach booted state: ${_.stderr||_.message}`),process.exit(1)}}async function te(e,_,t,C){let S=!1;for(let B=0;B<30;B++){if(!C())break;try{if((await fetch(`${_}/health`)).ok){S=!0;break}}catch{}await new Promise((i)=>setTimeout(i,100))}if(S){let B=Date.now()+8000;while(Date.now()<B){if(await new Promise((i)=>setTimeout(i,200)),!C()){S=!1;break}try{if(v(t,"utf-8").includes("Capture started"))break}catch{}}}let A="";try{A=v(t,"utf-8").trim()}catch{}return{ready:S,log:A}}async function Me(e){let{helperPath:_,udid:t,port:C,host:S,logFile:A}=e,B=`http://${S}:${C}`;q();let i=J(A,"w"),r=x(_,[t,"--port",String(C)],{detached:!0,stdio:["ignore",i,i]});r.unref(),Q(i);let s=r.pid,R=!1;r.once("exit",()=>{R=!0});let{ready:D,log:o}=await te(s,B,A,()=>!R&&I(s));return{ready:D,pid:s,exited:R||!I(s),log:o}}async function Ie(e){let{helperPath:_,udid:t,port:C,host:S,logFile:A}=e,B=`http://${S}:${C}`;q();let i=J(A,"w"),r=x(_,[t,"--port",String(C)],{detached:!1,stdio:["ignore",i,i]});Q(i);let s=r.pid,R=!1;r.once("exit",()=>{R=!0});let{ready:D,log:o}=await te(s,B,A,()=>!R&&I(s));return{ready:D,child:r,log:o}}async function Ce(e,_,t){await Le(e);let C="127.0.0.1",S=me(),A=ve(b,`server-${e}.log`),B={helperPath:S,udid:e,port:_,host:C,logFile:A},i="",r=2;for(let R=1;R<=r;R++){if(Ne(_),t.detach){let D=await Me(B);if(D.ready){let o={pid:D.pid,port:_,device:e,url:`http://${C}:${_}`,streamUrl:`http://${C}:${_}/stream.mjpeg`,wsUrl:`ws://${C}:${_}/ws`};return X(o),{pid:D.pid}}G(D.pid),i=D.log}else{let D=await Ie(B);if(D.ready){let o={pid:D.child.pid,port:_,device:e,url:`http://${C}:${_}`,streamUrl:`http://${C}:${_}/stream.mjpeg`,wsUrl:`ws://${C}:${_}/ws`};return X(o),{pid:D.child.pid,child:D.child}}G(D.child.pid),i=D.log}if(R<r)await new Promise((D)=>setTimeout(D,500))}let s=i?`Helper failed:
+${i}`:"Helper process failed to start";console.error(s),process.exit(1)}async function Ge(e,_,t){let C=e.length>0?e.map(E):(()=>{let s=Y();if(!s)console.error("No device specified and no booted simulator found."),process.exit(1);return[s]})(),S=new Map,A=[],B=_;for(let s of C){let R=p(s);if(R){if(!t){let c=z(s)??s;if(C.length>1)console.log(`
+==> ${c} (${s}) <==`);console.log(`  Already running on port ${R.port}`),console.log(`  Stream:    ${R.streamUrl}`),console.log(`  WebSocket: ${R.wsUrl}`)}A.push(R);continue}B=await _e(B);let{pid:D,child:o}=await Ce(s,B,{detach:!1});if(o)S.set(s,o);let H="127.0.0.1",h={pid:D,port:B,device:s,url:`http://${H}:${B}`,streamUrl:`http://${H}:${B}/stream.mjpeg`,wsUrl:`ws://${H}:${B}/ws`};if(A.push(h),!t){let c=z(s)??s;if(C.length>1)console.log(`
+==> ${c} (${s}) <==`);console.log(`  Stream:    ${h.streamUrl}`),console.log(`  WebSocket: ${h.wsUrl}`),console.log(`  Port:      ${B}`)}B++}if(A.length===1){let s=A[0];console.log(JSON.stringify({url:s.url,streamUrl:s.streamUrl,wsUrl:s.wsUrl,port:s.port,device:s.device}))}else console.log(JSON.stringify({devices:A.map((s)=>({url:s.url,streamUrl:s.streamUrl,wsUrl:s.wsUrl,port:s.port,device:s.device}))}));if(S.size===0)return;let i=!1,r=(s)=>{if(i)return;if(i=!0,!t)console.log(`
+Shutting down...`);for(let[R,D]of S){let o=D.pid;if(o)G(o);l(R)}S.clear(),process.exit(s)};for(let[s,R]of S)R.on("exit",(D)=>{if(i)return;if(!t)console.error(`[${s}] Helper exited (code ${D})`);if(l(s),S.delete(s),S.size===0)r(D??1)});process.on("SIGINT",()=>r(0)),process.on("SIGTERM",()=>r(0)),process.on("SIGHUP",()=>r(0)),process.on("exit",()=>{for(let[s,R]of S){try{if(R.pid)process.kill(R.pid,"SIGTERM")}catch{}try{l(s)}catch{}}}),await new Promise(()=>{})}async function se(e,_){let t=e.length>0?e.map(E):(()=>{let A=Y();if(!A)console.error("No device specified and no booted simulator found."),process.exit(1);return[A]})(),C=[],S=_;for(let A of t){let B=p(A);if(B){C.push(B);continue}S=await _e(S),await Ce(A,S,{detach:!0});let i="127.0.0.1";C.push({pid:p(A).pid,port:S,device:A,url:`http://${i}:${S}`,streamUrl:`http://${i}:${S}/stream.mjpeg`,wsUrl:`ws://${i}:${S}/ws`}),S++}return C}function qe(e){if(e.length===1){let _=e[0];console.log(JSON.stringify({url:_.url,streamUrl:_.streamUrl,wsUrl:_.wsUrl,port:_.port,device:_.device}))}else console.log(JSON.stringify({devices:e.map((_)=>({url:_.url,streamUrl:_.streamUrl,wsUrl:_.wsUrl,port:_.port,device:_.device}))}))}function ke(e){if(e){let t=E(e),C=p(t);if(!C)console.log(JSON.stringify({running:!1,device:t}));else console.log(JSON.stringify({running:!0,url:C.url,streamUrl:C.streamUrl,wsUrl:C.wsUrl,port:C.port,device:C.device,pid:C.pid}));return}let _=m();if(_.length===0)console.log(JSON.stringify({running:!1}));else if(_.length===1){let t=_[0];console.log(JSON.stringify({running:!0,url:t.url,streamUrl:t.streamUrl,wsUrl:t.wsUrl,port:t.port,device:t.device,pid:t.pid}))}else console.log(JSON.stringify({running:!0,streams:_.map((t)=>({url:t.url,streamUrl:t.streamUrl,wsUrl:t.wsUrl,port:t.port,device:t.device,pid:t.pid}))}))}function Pe(e){if(e){let _=E(e),t=p(_);if(!t){console.log(JSON.stringify({disconnected:!0,device:_}));return}try{process.kill(t.pid,"SIGTERM")}catch{}l(_),console.log(JSON.stringify({disconnected:!0,device:t.device}))}else{let _=m();if(_.length===0){console.log(JSON.stringify({disconnected:!0,devices:[]}));return}let t=[];for(let C of _){try{process.kill(C.pid,"SIGTERM")}catch{}t.push(C.device)}l(),console.log(JSON.stringify({disconnected:!0,devices:t}))}}async function Ue(e){let _,t=[];for(let B=0;B<e.length;B++)if(e[B]==="--device"||e[B]==="-d")_=e[++B];else t.push(e[B]);let C=p(_);if(!C)console.error("No serve-sim server running. Run `serve-sim` first."),process.exit(1);let S=t[0];if(!S)console.error("Usage: serve-sim gesture '<json>'"),console.error(`Example: serve-sim gesture '{"type":"begin","x":0.5,"y":0.5}'`),process.exit(1);let A;try{A=JSON.parse(S)}catch{console.error("Invalid JSON:",S),process.exit(1)}return new Promise((B,i)=>{let r=new WebSocket(C.wsUrl);r.binaryType="arraybuffer",r.onopen=()=>{let s=new TextEncoder().encode(JSON.stringify(A)),R=new Uint8Array(1+s.length);R[0]=3,R.set(s,1),r.send(R),setTimeout(()=>{r.close(),B()},50)},r.onerror=()=>{console.error("Failed to connect to serve-sim server at",C.wsUrl),i(Error("WebSocket connection failed"))}})}async function Ke(e){let _,t=[];for(let A=0;A<e.length;A++)if(e[A]==="--device"||e[A]==="-d")_=e[++A];else t.push(e[A]);let C=p(_);if(!C)console.error("No serve-sim server running. Run `serve-sim` first."),process.exit(1);let S=t[0]??"home";return new Promise((A,B)=>{let i=new WebSocket(C.wsUrl);i.binaryType="arraybuffer",i.onopen=()=>{let r=new TextEncoder().encode(JSON.stringify({button:S})),s=new Uint8Array(1+r.length);s[0]=4,s.set(r,1),i.send(s),setTimeout(()=>{i.close(),A()},50)},i.onerror=()=>{console.error("Failed to connect to serve-sim server at",C.wsUrl),B(Error("WebSocket connection failed"))}})}async function Xe(e,_){if(m().length===0)console.log("Starting simulator stream..."),await se(_,3100);let{simMiddleware:C}=await Promise.resolve().then(() => (K(),U)),S=C({basePath:"/"});Bun.serve({port:e,idleTimeout:255,async fetch(B){return new Promise((i)=>{let r=new URL(B.url),s={url:r.pathname+r.search,method:B.method,headers:Object.fromEntries(B.headers.entries()),on(n,$){}},R=[];s.on=(n,$)=>{if(n==="close")R.push($)},B.signal.addEventListener("abort",()=>{for(let n of R)n()});let D=200,o=new Headers,H=[],h=!1,c=null;S(s,{writeHead(n,$){if(D=n,$)for(let[f,ae]of Object.entries($))o.set(f,ae)},setHeader(n,$){o.set(n,$)},get statusCode(){return D},set statusCode(n){D=n},write(n){if(!h){h=!0;let $=new ReadableStream({start(f){c=f}});i(new Response($,{status:D,headers:o}))}try{c?.enqueue(typeof n==="string"?new TextEncoder().encode(n):n)}catch{}},end(n){if(h){if(n)try{c?.enqueue(typeof n==="string"?new TextEncoder().encode(n):n)}catch{}try{c?.close()}catch{}}else{if(n)H.push(n);let $=H.map((f)=>typeof f==="string"?f:new TextDecoder().decode(f)).join("");i(new Response($,{status:D,headers:o}))}}},()=>{i(new Response("Not found",{status:404}))})})}});let A=We();if(console.log(""),console.log(`  - Local:   http://localhost:${e}`),A)console.log(`  - Network: http://${A}:${e}`);console.log(""),process.on("SIGINT",()=>process.exit(0)),process.on("SIGTERM",()=>process.exit(0)),await new Promise(()=>{})}function Se(){console.log(`
+serve-sim - Stream iOS Simulator to the browser
+
+Usage:
+  serve-sim [device...]                 Start preview server (default: localhost:3200)
+  serve-sim --no-preview [device...]    Stream in foreground without a preview server
+  serve-sim gesture '<json>' [-d udid]  Send a touch gesture
+  serve-sim button [name] [-d udid]     Send a button press (default: home)
+
+Options:
+  -p, --port <port>   Starting port (preview default: 3200, stream default: 3100)
+  -d, --detach        Spawn helper and exit (daemon mode)
+  -q, --quiet         Suppress human-readable output, JSON only
+      --no-preview    Skip the web preview server; stream in foreground only
+      --list [device] List running streams
+      --kill [device] Kill running stream(s)
+  -h, --help          Show this help
+
+Examples:
+  serve-sim                             Open simulator preview at localhost:3200
+  serve-sim -p 8080                     Preview on a custom port
+  serve-sim --no-preview                Auto-detect booted sim, stream in foreground
+  serve-sim --no-preview "iPhone 16 Pro" Stream a specific device (no preview)
+  serve-sim --detach                    Start streaming in background (daemon)
+  serve-sim --list                      Show all running streams
+  serve-sim --kill                      Stop all streams
+`)}var a=process.argv.slice(2);if(a[0]==="gesture")await Ue(a.slice(1)),process.exit(0);if(a[0]==="button")await Ke(a.slice(1)),process.exit(0);var w,Ae=!1,Be=!1,ie=!1,re=!1,De=!1,Re=!1,O=[],oe,ne;for(let e=0;e<a.length;e++){let _=a[e];switch(_){case"--port":case"-p":w=parseInt(a[++e]??"3100",10);break;case"--detach":case"-d":Ae=!0;break;case"--quiet":case"-q":Be=!0;break;case"--no-preview":Re=!0;break;case"--list":case"-l":if(ie=!0,a[e+1]&&!a[e+1].startsWith("-"))oe=a[++e];break;case"--kill":case"-k":if(re=!0,a[e+1]&&!a[e+1].startsWith("-"))ne=a[++e];break;case"--help":case"-h":case"help":De=!0;break;default:if(!_.startsWith("-"))O.push(_);else console.error(`Unknown flag: ${_}`),Se(),process.exit(1)}}if(De)Se(),process.exit(0);if(ie)ke(oe),process.exit(0);if(re)Pe(ne),process.exit(0);if(Ae){let e=await se(O,w??3100);qe(e)}else if(Re)await Ge(O,w??3100,Be);else await Xe(w??3200,O);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "serve-sim",
+  "version": "0.0.0",
+  "type": "module",
+  "bin": {
+    "serve-sim": "dist/serve-sim.js"
+  },
+  "files": [
+    "dist/serve-sim.js",
+    "dist/middleware.js",
+    "dist/middleware.cjs",
+    "src/middleware.ts",
+    "src/state.ts",
+    "bin/serve-sim-bin"
+  ],
+  "exports": {
+    "./middleware": {
+      "require": "./dist/middleware.cjs",
+      "import": "./dist/middleware.js",
+      "types": "./src/middleware.ts"
+    },
+    "./state": {
+      "import": "./src/state.ts",
+      "types": "./src/state.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "build:swift": "./build.sh",
+    "dev": "bun run dev.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "mac-mini-client": "workspace:*",
+    "preact": "^10.29.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/middleware.ts

@@ -0,0 +1,147 @@
+import { readdirSync, readFileSync } from "fs";
+import { spawn, type ChildProcess } from "child_process";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// Injected at build time as a base64-encoded string via `define`
+declare const __PREVIEW_HTML_B64__: string;
+const STATE_DIR = join(tmpdir(), "serve-sim");
+
+interface ServeSimState {
+  pid: number;
+  port: number;
+  device: string;
+  url: string;
+  streamUrl: string;
+  wsUrl: string;
+}
+
+function readServeSimStates(): ServeSimState[] {
+  let files: string[];
+  try {
+    files = readdirSync(STATE_DIR).filter(
+      (f) => f.startsWith("server-") && f.endsWith(".json"),
+    );
+  } catch {
+    return [];
+  }
+  const states: ServeSimState[] = [];
+  for (const f of files) {
+    try {
+      const state: ServeSimState = JSON.parse(readFileSync(join(STATE_DIR, f), "utf-8"));
+      try {
+        process.kill(state.pid, 0);
+        states.push(state);
+      } catch {}
+    } catch {}
+  }
+  return states;
+}
+
+let _html: string | null = null;
+function loadHtml(): string {
+  if (!_html) {
+    _html = Buffer.from(__PREVIEW_HTML_B64__, "base64").toString("utf-8");
+  }
+  return _html;
+}
+
+export interface SimMiddlewareOptions {
+  /** Base path to serve the preview at. Default: "/.sim" */
+  basePath?: string;
+}
+
+/**
+ * Connect-style middleware that serves the simulator preview UI.
+ *
+ * Routes handled under `basePath` (default `/.sim`):
+ *   GET  {basePath}         — the preview HTML page
+ *   GET  {basePath}/api     — serve-sim state JSON
+ *   GET  {basePath}/logs    — SSE stream of simctl logs
+ */
+export function simMiddleware(options?: SimMiddlewareOptions) {
+  const base = (options?.basePath ?? "/.sim").replace(/\/+$/, "");
+
+  return (req: any, res: any, next?: () => void) => {
+    const url: string = req.url ?? "";
+
+    // Serve the preview page
+    if (url === base || url === base + "/") {
+      const states = readServeSimStates();
+      const state = states[0] ?? null;
+      let html = loadHtml();
+
+      if (state) {
+        // Pass real serve-sim URLs directly. The client parses the MJPEG
+        // stream via fetch() (CORS is fine — serve-sim sends Access-Control-Allow-Origin: *)
+        // and connects to the WS directly (WS has no CORS).
+        const config = JSON.stringify({
+          ...state,
+          logsEndpoint: base + "/logs",
+        });
+        const configScript = `<script>window.__SIM_PREVIEW__=${config}</script>`;
+        html = html.replace("<!--__SIM_PREVIEW_CONFIG__-->", configScript);
+      }
+
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+      });
+      res.end(html);
+      return;
+    }
+
+    // JSON API: serve-sim state
+    if (url === base + "/api") {
+      const states = readServeSimStates();
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store",
+      });
+      res.end(JSON.stringify(states[0] || null));
+      return;
+    }
+
+    // SSE: simctl log stream
+    if (url === base + "/logs" || url.startsWith(base + "/logs?")) {
+      const states = readServeSimStates();
+      if (states.length === 0) {
+        res.writeHead(404);
+        res.end("No serve-sim device");
+        return;
+      }
+      const udid = states[0].device;
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+      });
+      res.write(":\n\n");
+
+      const child: ChildProcess = spawn("xcrun", [
+        "simctl", "spawn", udid, "log", "stream",
+        "--style", "ndjson",
+        "--level", "info",
+      ], { stdio: ["ignore", "pipe", "ignore"] });
+
+      let buf = "";
+      child.stdout!.on("data", (chunk: Buffer) => {
+        buf += chunk.toString();
+        let nl: number;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+          const line = buf.slice(0, nl).trim();
+          buf = buf.slice(nl + 1);
+          if (line) res.write("data: " + line + "\n\n");
+        }
+      });
+
+      child.on("close", () => res.end());
+      req.on("close", () => child.kill());
+      return;
+    }
+
+    // Not ours — pass through
+    if (next) next();
+  };
+}

package/src/state.ts

@@ -0,0 +1,26 @@
+import { tmpdir } from "os";
+import { join } from "path";
+import { readdirSync } from "fs";
+
+/** Directory where serve-sim stores runtime state. */
+export const STATE_DIR = join(tmpdir(), "serve-sim");
+
+/** Path to the serve-sim server state file (JSON with pid, port, URLs).
+ *  @deprecated Use `stateFileForDevice(udid)` for multi-device support. Kept for backward compat. */
+export const STATE_FILE = join(STATE_DIR, "server.json");
+
+/** Per-device state file: `/tmp/serve-sim/server-{udid}.json` */
+export function stateFileForDevice(udid: string): string {
+  return join(STATE_DIR, `server-${udid}.json`);
+}
+
+/** List all per-device state files in the state directory. */
+export function listStateFiles(): string[] {
+  try {
+    return readdirSync(STATE_DIR)
+      .filter((f) => f.startsWith("server-") && f.endsWith(".json"))
+      .map((f) => join(STATE_DIR, f));
+  } catch {
+    return [];
+  }
+}