@upstart.gg/sdk 0.0.130 → 0.0.132

package/src/shared/utils/canvas-data-uri.ts

@@ -0,0 +1,2 @@
+export const canvasDataURI =
+  "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1600 900" id="landscape-scene">
  <defs>
    <linearGradient id="c" x1="1193.84" x2="1120.16" y1="277.8" y2="728.55" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#fff"></stop>
      <stop offset="1" stop-color="#666"></stop>
    </linearGradient>
    <linearGradient xlink:href="#c" id="h" x1="334.55" x2="593.75" y1="183" y2="960.6"></linearGradient>
    <linearGradient id="q" x1="783.53" x2="812.33" y1="-58.36" y2="552.2" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#71add2"></stop>
      <stop offset="1" stop-color="#fff"></stop>
    </linearGradient>
    <linearGradient id="i" x1="1193.84" x2="1120.16" y1="277.8" y2="728.55" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#f2f2f2"></stop>
      <stop offset="1" stop-color="#9abddb"></stop>
    </linearGradient>
    <linearGradient xlink:href="#i" id="t" x1="334.55" x2="593.75" y1="183" y2="960.6"></linearGradient>
    <linearGradient id="k" x1="466.33" x2="457.69" y1="219.4" y2="927.88" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#9be6ee"></stop>
      <stop offset="1" stop-color="#d1e5ff"></stop>
    </linearGradient>
    <linearGradient id="j" x1="466.31" x2="457.72" y1="221.44" y2="925.41" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#91eeec"></stop>
      <stop offset="1" stop-color="#d1e5ff"></stop>
    </linearGradient>
    <linearGradient id="u" x1="1009.16" x2="1001.75" y1="260.75" y2="868.56" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#79dde8"></stop>
      <stop offset="1" stop-color="#d1e5ff"></stop>
    </linearGradient>
    <linearGradient xlink:href="#j" id="v" x1="1009.16" x2="1001.75" y1="260.75" y2="868.56"></linearGradient>
    <linearGradient xlink:href="#k" id="w" x1="764.47" x2="807.67" y1="300.27" y2="1121.07"></linearGradient>
    <linearGradient xlink:href="#j" id="x" x1="651.11" x2="687.71" y1="314.33" y2="1009.83"></linearGradient>
    <linearGradient id="y" x1="935.72" x2="952.07" y1="251.52" y2="720.12" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#ecfc71"></stop>
      <stop offset=".9" stop-color="#99f28f"></stop>
    </linearGradient>
    <linearGradient id="z" x1="936.4" x2="951.18" y1="270.98" y2="694.69" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#ecfc71"></stop>
      <stop offset=".9" stop-color="#b2f2ab"></stop>
    </linearGradient>
    <linearGradient id="l" x1="962.25" x2="944.36" y1="525.49" y2="562.65" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#a67e1b"></stop>
      <stop offset=".98" stop-color="#b56d2e"></stop>
    </linearGradient>
    <linearGradient id="m" x1="1001.04" x2="926.16" y1="345.53" y2="501.05" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#388830"></stop>
      <stop offset="1" stop-color="#4fd141"></stop>
    </linearGradient>
    <linearGradient xlink:href="#l" id="A" x1="1065.86" x2="1047.97" y1="548.27" y2="585.44"></linearGradient>
    <linearGradient xlink:href="#m" id="B" x1="1093.05" x2="1035.46" y1="413.27" y2="532.88"></linearGradient>
    <linearGradient xlink:href="#l" id="C" x1="379.61" x2="366.32" y1="474.51" y2="502.1"></linearGradient>
    <linearGradient xlink:href="#m" id="D" x1="396.28" x2="358.84" y1="388.09" y2="465.85"></linearGradient>
    <linearGradient id="E" x1="572.15" x2="582.38" y1="838.14" y2="510.72" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#71e960"></stop>
      <stop offset="1" stop-color="#effc8b"></stop>
    </linearGradient>
    <linearGradient id="F" x1="579.31" x2="582.32" y1="609.06" y2="512.6" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#78e968"></stop>
      <stop offset="1" stop-color="#ecfc71"></stop>
    </linearGradient>
    <linearGradient id="n" x1="838.34" x2="865.31" y1="540.53" y2="918.1" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#b0d968"></stop>
      <stop offset="1" stop-color="#4fd141"></stop>
    </linearGradient>
    <linearGradient xlink:href="#n" id="G" x1="847.31" x2="854.27" y1="591.89" y2="689.32"></linearGradient>
    <linearGradient id="o" x1="812.47" x2="799.56" y1="905.95" y2="613.5" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#bbaf51"></stop>
      <stop offset="1" stop-color="#fceb6c"></stop>
    </linearGradient>
    <linearGradient xlink:href="#m" id="H" x1="522.76" x2="527.98" y1="817.02" y2="699.15"></linearGradient>
    <linearGradient xlink:href="#m" id="I" x1="786.61" x2="807.62" y1="1113.11" y2="638.33"></linearGradient>
    <linearGradient xlink:href="#o" id="J" x1="1309.46" x2="1333.89" y1="747.72" y2="903.82"></linearGradient>
    <linearGradient id="K" x1="490.83" x2="631.73" y1="981.45" y2="702.36" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#51b846"></stop>
      <stop offset="1" stop-color="#45883f"></stop>
    </linearGradient>
    <linearGradient xlink:href="#m" id="L" x1="230.7" x2="239.92" y1="708.13" y2="780.09"></linearGradient>
    <linearGradient xlink:href="#l" id="M" x1="246.59" x2="249.3" y1="687.09" y2="744.45"></linearGradient>
    <linearGradient xlink:href="#l" id="N" x1="241.61" x2="244.3" y1="687.33" y2="744.34"></linearGradient>
    <linearGradient id="p" x1="-2670.61" x2="-2634.26" y1="404.78" y2="637" gradientTransform="matrix(-1 0 0 1 -2390.88 0)" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#59b84f"></stop>
      <stop offset="1" stop-color="#388830"></stop>
    </linearGradient>
    <linearGradient xlink:href="#p" id="O" x1="211.21" x2="247.51" y1="405.9" y2="637.87"></linearGradient>
    <linearGradient xlink:href="#p" id="P" x1="264.59" x2="276.42" y1="576.67" y2="612.17"></linearGradient>
    <linearGradient xlink:href="#p" id="Q" x1="263.65" x2="264.36" y1="460.34" y2="437.71"></linearGradient>
    <linearGradient xlink:href="#m" id="R" x1="1495.24" x2="1504.34" y1="762.93" y2="833.92"></linearGradient>
    <linearGradient xlink:href="#l" id="S" x1="1545.48" x2="1355.08" y1="723.94" y2="723.94"></linearGradient>
    <linearGradient xlink:href="#l" id="T" x1="1498.22" x2="1414.15" y1="668.48" y2="668.48"></linearGradient>
    <linearGradient xlink:href="#l" id="U" x1="1531.08" x2="1427.09" y1="728.75" y2="728.75"></linearGradient>
    <linearGradient xlink:href="#p" id="V" x1="1444.3" x2="1503.49" y1="207.83" y2="673.93"></linearGradient>
    <linearGradient xlink:href="#p" id="W" x1="1464.27" x2="1523.46" y1="205.31" y2="671.41"></linearGradient>
    <linearGradient xlink:href="#p" id="X" x1="1445.42" x2="1479.77" y1="407.83" y2="571.31"></linearGradient>
    <linearGradient xlink:href="#p" id="Y" x1="1456.68" x2="1459.74" y1="291.24" y2="378.82"></linearGradient>
    <linearGradient xlink:href="#m" id="Z" x1="1330.85" x2="1339.95" y1="762.93" y2="833.92"></linearGradient>
    <linearGradient xlink:href="#l" id="aa" x1="1333.26" x2="1312.39" y1="722.36" y2="850.06"></linearGradient>
    <linearGradient xlink:href="#l" id="ab" x1="1333.32" x2="1312.84" y1="722" y2="847.33"></linearGradient>
    <linearGradient xlink:href="#p" id="ac" x1="1271.32" x2="1357.79" y1="321.07" y2="708.46"></linearGradient>
    <linearGradient xlink:href="#p" id="ad" x1="1286.6" x2="1373.07" y1="317.67" y2="705.05"></linearGradient>
    <linearGradient xlink:href="#p" id="ae" x1="457.83" x2="363.14" y1="58.39" y2="58.39" gradientTransform="rotate(26.48 -115.307 2103.291)"></linearGradient>
    <linearGradient xlink:href="#p" id="af" x1="1339.45" x2="1244.76" y1="426.66" y2="426.66"></linearGradient>
    <linearGradient xlink:href="#p" id="ag" x1="1322.36" x2="1240.57" y1="442.67" y2="442.67"></linearGradient>
    <linearGradient xlink:href="#m" id="ah" x1="95.29" x2="104.52" y1="718.23" y2="790.19"></linearGradient>
    <linearGradient xlink:href="#p" id="ai" x1="178.3" x2="201.59" y1="108.41" y2="776" gradientTransform="translate(-129.71 -73.73)"></linearGradient>
    <linearGradient xlink:href="#p" id="aj" x1="71.92" x2="95.29" y1="20.28" y2="689.96"></linearGradient>
    <linearGradient xlink:href="#p" id="ak" x1="131.77" x2="134.85" y1="397.61" y2="485.77"></linearGradient>
    <linearGradient xlink:href="#l" id="al" x1="91.37" x2="150.45" y1="656.47" y2="833.72"></linearGradient>
    <linearGradient xlink:href="#p" id="am" x1="2421.1" x2="2421.5" y1="955.07" y2="942.51" gradientTransform="matrix(.47 -.14 .31 .99 -1318.21 -153.44)"></linearGradient>
    <linearGradient xlink:href="#p" id="an" x1="785.78" x2="786.06" y1="1320.59" y2="1311.64" gradientTransform="matrix(.86 -.32 .48 1.32 -1207.57 -1079.58)"></linearGradient>
    <filter id="a" width="796.51" height="32766" x="775.58" y="-8642" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse">
      <feFlood flood-color="#fff" result="bg"></feFlood>
      <feBlend in="SourceGraphic" in2="bg"></feBlend>
    </filter>
    <filter id="b" width="762.07" height="32766" x="37.93" y="-8642" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse">
      <feFlood flood-color="#fff" result="bg"></feFlood>
      <feBlend in="SourceGraphic" in2="bg"></feBlend>
    </filter>
    <filter id="e" width="796.51" height="389.15" x="775.58" y="180.9" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse">
      <feFlood flood-color="#fff" result="bg"></feFlood>
      <feBlend in="SourceGraphic" in2="bg"></feBlend>
    </filter>
    <filter id="g" width="762.07" height="373.55" x="37.93" y="163.7" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse">
      <feFlood flood-color="#fff" result="bg"></feFlood>
      <feBlend in="SourceGraphic" in2="bg"></feBlend>
    </filter>
    <mask id="r" width="796.51" height="389.15" x="775.58" y="180.9" maskUnits="userSpaceOnUse">
      <g filter="url(#e)" mask="url(#d)">
        <path fill="url(#c)" d="M1452,330a120.79,120.79,0,0,0-19.8,1.64,120.16,120.16,0,0,0-135.42-62.34,158.29,158.29,0,0,0-194.25-41,102.67,102.67,0,0,0-176.45,5.83,120.26,120.26,0,1,0-30.29,236.65c54,0,196.77,56.77,278.45,56.77a157.59,157.59,0,0,0,97.84-33.87,120.24,120.24,0,0,0,72.85,10.7A120.06,120.06,0,1,0,1452,330Z" style="mix-blend-mode:multiply"></path>
      </g>
    </mask>
    <mask id="s" width="762.07" height="373.55" x="37.93" y="163.7" maskUnits="userSpaceOnUse">
      <g filter="url(#g)" mask="url(#f)">
        <path fill="url(#h)" d="M800,414.58a92.66,92.66,0,0,0-111.81-90.65A144.15,144.15,0,0,0,482.92,212.59a114.45,114.45,0,0,0-205.17,39.16,134.79,134.79,0,0,0-14.43-.78A132.75,132.75,0,0,0,130.57,383.72c0,.55,0,1.1,0,1.66a76.77,76.77,0,1,0-15.9,151.88H727.14v0a44,44,0,0,0,42.2-53.84A92.38,92.38,0,0,0,800,414.58Z" style="mix-blend-mode:multiply"></path>
      </g>
    </mask>
  </defs>
  <g>
    <rect width="1600" height="580.39" y=".64" fill="url(#q)"></rect>
    <g mask="url(#r)">
      <path fill="url(#i)" d="M1452,330a120.79,120.79,0,0,0-19.8,1.64,120.16,120.16,0,0,0-135.42-62.34,158.29,158.29,0,0,0-194.25-41,102.67,102.67,0,0,0-176.45,5.83,120.26,120.26,0,1,0-30.29,236.65c54,0,196.77,56.77,278.45,56.77a157.59,157.59,0,0,0,97.84-33.87,120.24,120.24,0,0,0,72.85,10.7A120.06,120.06,0,1,0,1452,330Z"></path>
    </g>
    <g mask="url(#s)">
      <path fill="url(#t)" d="M800,414.58a92.66,92.66,0,0,0-111.81-90.65A144.15,144.15,0,0,0,482.92,212.59a114.45,114.45,0,0,0-205.17,39.16,134.79,134.79,0,0,0-14.43-.78A132.75,132.75,0,0,0,130.57,383.72c0,.55,0,1.1,0,1.66a76.77,76.77,0,1,0-15.9,151.88H727.14v0a44,44,0,0,0,42.2-53.84A92.38,92.38,0,0,0,800,414.58Z"></path>
    </g>
    <path fill="url(#k)" d="M149.22,536.91s277.6-148,329.44-166.34,297,168.17,297,168.17Z"></path>
    <path fill="url(#j)" d="M251.3,536.91S419,553.33,450.37,430.77c-28.43-13.64,40.66-64.57,28.29-60.2-51.84,18.32-329.44,166.34-329.44,166.34l626.46,1.83-.4-.3Z" opacity=".72" style="mix-blend-mode:screen"></path>
    <path fill="url(#u)" d="M737.11,533.15s238.15-127,282.63-142.7,254.81,144.27,254.81,144.27Z"></path>
    <path fill="url(#v)" d="M914.69,494s75.36-90.65,150.4-93.77c-20-8.75-36.19-13-45.35-9.74-44.48,15.72-282.63,142.7-282.63,142.7l537.44,1.57-.27-.2Z" opacity=".72" style="mix-blend-mode:screen"></path>
    <path fill="url(#w)" d="M462.45,512.41s263.76-163,309.79-159.34c17.23,1.36,61,39.48,80.07,53.43S926,434.37,964.07,444.61,1088.7,510,1088.7,510l-333,43.32Z"></path>
    <path fill="url(#x)" d="M772.24,373c17.23,1.36,99.15,47.45,80.07,33.5s-62.84-52.07-80.07-53.43c-46-3.63-309.79,159.34-309.79,159.34l91.09,21.09C832,511,735.21,370.08,772.24,373Z" opacity=".72" style="mix-blend-mode:screen"></path>
    <path fill="url(#y)" d="M1600,436.51s-422.72-14.21-800,83.71S293.46,697.76,293.46,697.76L1600,675.55Z"></path>
    <path fill="url(#z)" d="M800,520.22C422.72,618.14,293.46,697.76,293.46,697.76h0C338.56,674.27,498.06,607.35,800,529c377.28-97.92,800-92.47,800-92.47h0S1177.28,422.3,800,520.22Z" opacity=".46" style="mix-blend-mode:screen"></path>
    <rect width="8.15" height="41.57" x="946.73" y="528.48" fill="url(#l)"></rect>
    <path fill="url(#m)" d="M932.75,373.3s-17.64,61.17-12.06,103.54,18.54,70.54,40.14,57.32,22-61.89,20.77-80.16-12.13-51.42-12.13-51.42-4.93-57.44-18.67-52.21S932.75,373.3,932.75,373.3Z"></path>
    <rect width="8.15" height="41.57" x="1050.34" y="551.26" fill="url(#A)"></rect>
    <path fill="url(#B)" d="M1040.53,434.63s-13.56,47.05-9.27,79.63,14.25,54.26,30.87,44.09,16.94-47.6,16-61.65-9.33-39.55-9.33-39.55S1065,413,1054.42,417,1040.53,434.63,1040.53,434.63Z"></path>
    <rect width="6.05" height="30.86" x="368.08" y="476.73" fill="url(#C)"></rect>
    <path fill="url(#D)" d="M362.13,402s-8.82,30.58-6,51.77,9.27,35.27,20.07,28.66,11-31,10.39-40.08-6.07-25.71-6.07-25.71-2.46-28.72-9.33-26.11S362.13,402,362.13,402Z"></path>
    <path fill="url(#E)" d="M0,505.81s111.37-9,431.46,3.1c406.08,15.32,730.12,108.45,730.12,108.45L0,786.64Z"></path>
    <path fill="url(#F)" d="M431.46,517c347.6,13.12,654.52,80.4,730.12,100.33h0s-324-93.13-730.12-108.45C111.37,496.83,0,505.81,0,505.81H0S111.37,505,431.46,517Z" opacity=".4" style="mix-blend-mode:screen"></path>
    <path fill="url(#n)" d="M108.58,751.45S472,633.71,854.29,609.56,1600,627.67,1600,627.67V900H108.58Z"></path>
    <path fill="url(#G)" d="M854.29,609.56C472,633.71,108.58,751.45,108.58,751.45h0S472,646.34,854.29,622.19,1600,627.67,1600,627.67h0S1236.63,585.41,854.29,609.56Z" opacity=".38" style="mix-blend-mode:screen"></path>
    <path fill="url(#o)" d="M675.09,627.28l66.52-7.65s77.92-1.94,145.95,53.53c76.91,62.72,26.76,113.48,26.76,113.48l-86.21,23.84S875.7,751.92,846.92,700C816.19,644.62,675.09,627.28,675.09,627.28Z"></path>
    <path fill="url(#H)" d="M1050.52,796.11S779.12,720.9,412.6,720.9H.18s96.91,6.86,419.62,6.86c366.52,0,630.72,68.35,630.72,68.35Z" opacity=".65" style="mix-blend-mode:screen"></path>
    <path fill="url(#I)" d="M0,721H412.42c366.52,0,637.92,75.2,637.92,75.2s145.44-17.81,311-18.6S1600,790.36,1600,790.36V900H0Z"></path>
    <path fill="url(#J)" d="M1050.34,796.16h0a1108.56,1108.56,0,0,1,243.15,80.51L1343.63,900H1600l-166.52-46.06a2208.52,2208.52,0,0,0-323.87-64h0Z"></path>
    <path fill="url(#K)" d="M307.38,720.92s40.44-24.77,82.64-27.27a62.33,62.33,0,0,1,39.46,11.09c17.16,11.68,40.22,15.56,61.27,9.85a147.69,147.69,0,0,1,76-.85c26.35,6.82,40.19,18.24,47.36,29.32,10.22,15.83,30,25.73,51.51,25,16.45-.54,35.82.67,55.25,6C771,788,780.63,845.7,780.63,845.7L846.92,900H718.08S606.29,751.61,307.38,720.92Z"></path>
    <path fill="url(#L)" d="M270.41,737.41c21.52,7.77-1.6,12.77-29.89,12.89,0,0-23.16,0-35.18-4.82-6.16-2.47-29.33-13.08-1-13.08C218.08,732.4,264.09,735.13,270.41,737.41Z" opacity=".32" style="mix-blend-mode:multiply"></path>
    <polygon fill="url(#M)" points="256.75 750.3 240.52 750.3 242.52 689.35 255.75 689.35 256.75 750.3"></polygon>
    <polygon fill="url(#N)" points="242.52 689.35 240.52 750.3 248.63 750.3 245.58 689.35 242.52 689.35" opacity=".27" style="mix-blend-mode:multiply"></polygon>
    <path fill="url(#p)" d="M248.77,693.51c19.47-.67,43.32-11.82,43.16-64.87L280.06,518l-4.2-16.57-8.21-65c-.91-8.17-6.85-15.15-17.35-15.15l-.88-9.48c-10.4,0-18.72,16-22.48,37.08-3,17-7.55,69.15-7.55,69.15s-5.36-4.06-5.87-2.23c-5,18.07-7.86,112.46-7.86,112.46C203.13,648.15,215.54,694.66,248.77,693.51Z"></path>
    <path fill="url(#O)" d="M225.82,628.22s2.87-94.39,7.86-112.46c.51-1.83,5.87,2.23,5.87,2.23s4.52-52.11,7.55-69.15c1.91-10.74,5-20.14,9-26.79a20.22,20.22,0,0,0-5.75-.81l-.88-9.48c-10.4,0-18.72,16-22.48,37.08-3,17-7.55,69.15-7.55,69.15s-5.36-4.06-5.87-2.23c-5,18.07-7.86,112.46-7.86,112.46-2.53,19.93,9.88,66.44,43.11,65.29a47.81,47.81,0,0,0,9.77-1.31C233.11,684.57,223.57,645.91,225.82,628.22Z" opacity=".29" style="mix-blend-mode:multiply"></path>
    <path fill="url(#P)" d="M255.15,579.48a29.11,29.11,0,0,1,12.21,0c6.66,1.44,13.23,14.1,13.23,14.1A55.38,55.38,0,0,0,255.15,579.48Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <path fill="url(#Q)" d="M268.54,443.41l1.87,14.82s-8-17.71-11.87-19.63S264.64,437.65,268.54,443.41Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <ellipse cx="1499.3" cy="794.61" fill="url(#R)" opacity=".32" rx="58.76" ry="9.6" style="mix-blend-mode:multiply"></ellipse>
    <polygon fill="url(#S)" points="1497.95 792.25 1470.47 792.25 1475.97 684.72 1460.86 655.63 1484.21 681.33 1513.75 665.25 1497.95 681.33 1497.95 792.25"></polygon>
    <g opacity=".3" style="mix-blend-mode:multiply">
      <polygon fill="url(#T)" points="1484.21 681.33 1460.86 655.63 1473.53 680.02 1484.21 681.33"></polygon>
      <path fill="url(#U)" d="M1490.3,684.93s3.45,21.42,3.76,28.63c2.06,48.77-9.2,78.69-9.2,78.69H1498V681.33l15.8-16.08Z"></path>
    </g>
    <path fill="url(#V)" d="M1489,679.92c-21.22-.78-56.32-14.67-64.09-78-5.94-48.47-4.73-105.53,0-156,1.25-13.34,9.21-3.64,10.95-17.34,3.43-27,7.88-54.44,13.64-81.19,2-9.47,6.31-11.44,6.82-21,2.08-39.16,18.71-70.5,32-97.58,0,0,12.71,27.59,21.79,54.58,6.69,19.89,4.32,32.28,5.52,37.41,2,8.65,7.88,11.39,9.77,23.9,3.77,24.85,13.12,39.88,16.24,89.12,1.48,23.38-.15,38,.14,67.27,0,0,11.62-2.37,11.3,48a266.09,266.09,0,0,1-4.56,46.72C1549.73,634.53,1517.83,681,1489,679.92Z"></path>
    <path fill="url(#W)" d="M1541.9,501c-.29-29.31,1.34-43.89-.14-67.27-3.12-49.24-12.47-64.27-16.24-89.12-1.89-12.51-7.76-15.25-9.77-23.9-1.2-5.13,1.17-17.52-5.52-37.41-9.08-27-21.79-54.58-21.79-54.58-4.56,9.3-9.52,19.11-14.15,29.56,3.1,7.8,14.15-29.56,22.29,13.37,3.9,20.61-10.06,44.44-7.54,49.06,24.71,45.14-3.63,38.53-1.74,51,3.77,24.85,27.48,44.84,36.75,98.42,4,23.08-9.15,1.53-8.86,30.84a312.58,312.58,0,0,1-1.48,87c-3.6,22.06,12-5.14,14.73,8.26,12,59.41-39,75.62-53.44,81.35a56.36,56.36,0,0,0,14.12,2.35c28.83,1.06,60.73-45.39,59.52-84.2A266.09,266.09,0,0,0,1553.2,549C1553.52,498.64,1541.9,501,1541.9,501Z" opacity=".49" style="mix-blend-mode:multiply"></path>
    <path fill="url(#X)" d="M1435.87,428.53s15.37,3.68,25,11.92,26.44,31.1,26.44,31.1-23.53-21.42-38.81-28.7-23.57,3-23.57,3A23.72,23.72,0,0,0,1435.87,428.53Z" opacity=".49" style="mix-blend-mode:multiply"></path>
    <path fill="url(#Y)" d="M1456.11,335.54s-5.35,5.85-6.6,11.8-5.51,27.93-5.51,27.93,18.28-40.28,29.61-46.46C1473.61,328.81,1469.23,327.3,1456.11,335.54Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <ellipse cx="1334.91" cy="794.61" fill="url(#Z)" opacity=".32" rx="58.76" ry="9.6" style="mix-blend-mode:multiply"></ellipse>
    <polygon fill="url(#aa)" points="1337.77 792.37 1317.69 792.37 1320.56 702.53 1337.77 703.48 1337.77 792.37"></polygon>
    <path fill="url(#ab)" d="M1320.56,702.53l0,.33s12.76,11.39,13.22,28.8c.4,15.23-5.56,60.71-5.56,60.71h9.57V703.48Z" opacity=".29" style="mix-blend-mode:multiply"></path>
    <path fill="url(#ac)" d="M1312.89,336.15a50.49,50.49,0,0,0-6.65,13.67c-9.11,30.59-36.1,123.51-36,150,.09,31.87-9.17,9.84-9.17,61.43s15.09,132.94,54,143.86,71.77-28.38,71.26-92.53c-.16-19.79-11.74-23.81-11.74-23.81s-3.31-66.4-4.58-114.66c-2.3-87.13-41.28-176.56-41.28-176.56s-14.9,22.17-13.76,30A12,12,0,0,1,1312.89,336.15Z"></path>
    <path fill="url(#ad)" d="M1374.55,588.78s-3.31-66.39-4.58-114.65c-2.3-87.14-41.28-176.57-41.28-176.57s-5,25.51,7.11,47.14c5.8,15.84-5.3,13.52,1.29,40.72,3,12.22,14.86,2.56,14.86,40.67,0,16.57,1.6,31.6-2.14,48-10.21,44.78-5.59,79-.87,97.91,1.1,4.43-12.1,17.93-11.17,20.63s8.36-.11,13-2.16A7.46,7.46,0,0,1,1359,592c3.25,3.21,7,9.37,7.13,20.64.4,51.1-20.38,86.44-48.52,93.17,37.75,8.51,69.18-30.45,68.68-93.17C1386.13,592.81,1374.55,588.78,1374.55,588.78Z" opacity=".49" style="mix-blend-mode:multiply"></path>
    <path fill="url(#ae)" d="M1300.23,511.68s-25.55,2.24-31.53,7.31S1275.66,498.18,1300.23,511.68Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <path fill="url(#af)" d="M1298.71,436.4c3.09-7.21,25-20.6,25-20.6C1295.66,414.66,1295.62,443.62,1298.71,436.4Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <path fill="url(#ag)" d="M1287,447.48c3.93-4.36,21.72-8.5,21.72-8.5C1290.81,431.33,1283.08,451.83,1287,447.48Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <path fill="url(#ah)" d="M135,747.51c21.51,7.77-1.6,12.77-29.89,12.89,0,0-23.16,0-35.18-4.82-6.17-2.47-29.34-13.08-1-13.08C82.68,742.5,128.69,745.23,135,747.51Z" opacity=".32" style="mix-blend-mode:multiply"></path>
    <path fill="url(#ai)" d="M98,312s-5.34,34.64-11.85,77.23C85,396.54,75.19,404.1,74,411.76c-7.53,49.44-6.94,103-9.85,124.17-6,43.51-4.67,75.6,6,97.59,7.07,14.56,34.32,41.93,64.06,9.43s16.62-133.68,16.62-133.68L138.73,481.5S123.91,287.76,98,312Z"></path>
    <path fill="url(#aj)" d="M82,593.58c2.18-24.35.6-36.6,13-58.86,3.59-6.42-11.28-73.52-3.75-123,1.17-7.66,17.28,0,12.12-22.55-6.28-27.4,3.76-70.41,10.09-65.79-4.6-11.49-9.79-16.79-15.52-11.44,0,0-5.34,34.64-11.85,77.23C85,396.54,75.19,404.1,74,411.76c-7.53,49.44-6.94,103-9.85,124.17-6,43.51-4.67,75.6,6,97.59,5.4,11.14,22.6,29.75,43.7,23.38C101,653,77.46,644.08,82,593.58Z" opacity=".29" style="mix-blend-mode:multiply"></path>
    <path fill="url(#ak)" d="M138.73,481.5h0a33.38,33.38,0,0,1-8-30.08l3.58-15.63Z" opacity=".29" style="mix-blend-mode:multiply"></path>
    <polygon fill="url(#al)" points="117.86 758.71 99.31 758.71 101.31 651.49 115.86 651.49 117.86 758.71"></polygon>
    <path fill="url(#am)" d="M92.66,429.07s4-3.57,7-2.18,8.92,8.9,8.92,8.9S99.45,427.28,92.66,429.07Z" opacity=".53" style="mix-blend-mode:screen"></path>
    <path fill="url(#an)" d="M93.65,410.64s10.36-8,15.77-6.58c8.64,2.28,11.29,7.12,11.29,7.12S106.18,406.49,93.65,410.64Z" opacity=".53" style="mix-blend-mode:screen"></path>
  </g>
</svg>";

package/src/shared/utils/invariant.ts

@@ -0,0 +1,25 @@
+const prefix: string = "Invariant failed";
+
+export default function invariant(
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  condition: any,
+  // Not providing an inline default argument for message as the result is smaller
+  /**
+   * Can provide a string, or a function that returns a string for cases where
+   * the message takes a fair amount of effort to compute
+   */
+  message?: string | (() => string),
+): asserts condition {
+  if (condition) {
+    return;
+  }
+
+  // When not in production we allow the message to pass through
+  const provided: string | undefined = typeof message === "function" ? message() : message;
+
+  // Options:
+  // 1. message provided: `${prefix}: ${provided}`
+  // 2. message not provided: prefix
+  const value: string = provided ? `${prefix}: ${provided}` : prefix;
+  throw new Error(value);
+}

package/src/shared/utils/json-date.ts

@@ -0,0 +1,8 @@
+import { Type, type TSchema, type StaticDecode, type StaticEncode } from "@sinclair/typebox";
+
+export const jsonDate = Type.Transform(Type.String({ format: "date-time" }))
+  .Decode((value) => new Date(value)) // decode: number to Date
+  .Encode((value) => value.toISOString());
+
+export type JsonDateObj = StaticDecode<typeof jsonDate>;
+export type JsonDateStr = StaticEncode<typeof jsonDate>;

package/src/shared/utils/llm.ts

@@ -0,0 +1,282 @@
+import type { TObject, TSchema } from "@sinclair/typebox";
+import { createAJVInstance } from "../ajv";
+import { cloneDeep } from "lodash-es";
+import type Ajv from "ajv";
+
+/**
+ * Clean all properties from custom metadata recursively. Custom metadata are key that:
+ * - Either with the name "metadata"
+ * - Or starting with "ui:"
+ * Also removes properties that have "ai:hidden" set to true
+ */
+export function toLLMSchema<T extends TSchema = TObject>(schema: T, ajv?: Ajv): T {
+  return cleanSchemaRecursive(inlineSchemaRefs(schema, ajv ?? createAJVInstance())) as T;
+}
+
+/**
+ * Recursively removes custom metadata from schema and filters out properties with ai:hidden = true
+ */
+function cleanSchemaRecursive(schema: TSchema): TSchema {
+  // Create a new object without custom metadata properties
+  const cleaned: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(schema)) {
+    // Skip metadata properties and ui: properties
+    if (key === "metadata" || key.startsWith("ui:")) {
+      continue;
+    }
+
+    // Handle nested objects and arrays
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        // Handle arrays - clean each item if it's a schema
+        cleaned[key] = value.map((item) => {
+          if (item && typeof item === "object" && isSchemaLike(item)) {
+            return cleanSchemaRecursive(item as TSchema);
+          }
+          return item;
+        });
+      } else if (isSchemaLike(value)) {
+        // Handle nested schemas
+        cleaned[key] = cleanSchemaRecursive(value as TSchema);
+      } else if (
+        key === "properties" ||
+        key === "definitions" ||
+        key === "$defs" ||
+        key === "patternProperties"
+      ) {
+        // Handle schema property collections - filter out properties with ai:hidden = true
+        const cleanedProps: Record<string, TSchema> = {};
+        for (const [propKey, propValue] of Object.entries(value)) {
+          if (propValue && typeof propValue === "object") {
+            // Check if this property should be hidden from AI
+            const propSchema = propValue as Record<string, unknown>;
+            if (propSchema["ai:hidden"] === true) {
+              continue; // Skip this property
+            }
+            cleanedProps[propKey] = cleanSchemaRecursive(propValue as TSchema);
+          } else {
+            cleanedProps[propKey] = propValue as TSchema;
+          }
+        }
+        cleaned[key] = cleanedProps;
+      } else {
+        // For other objects, recursively clean if they look like schemas
+        cleaned[key] = value;
+      }
+    } else {
+      // Keep primitive values as-is
+      cleaned[key] = value;
+    }
+  }
+
+  return cleaned as TSchema;
+}
+
+/**
+ * Helper function to determine if an object looks like a schema
+ */
+function isSchemaLike(obj: unknown): boolean {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+
+  const schemaKeys = [
+    "type",
+    "$ref",
+    "properties",
+    "items",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "not",
+    "if",
+    "then",
+    "else",
+  ];
+  return schemaKeys.some((key) => key in obj);
+}
+
+interface SchemaWithDefs extends TSchema {
+  $defs?: Record<string, TSchema>;
+}
+
+/**
+ * Inlines referenced schemas from AJV into the schema's $defs section
+ * @param schema - The schema containing $ref references
+ * @param ajv - The AJV instance containing the referenced schemas
+ * @returns A new schema with references inlined in $defs
+ */
+export function inlineSchemaRefs<T extends TSchema>(schema: T, ajv: Ajv) {
+  //
+  const inlinedSchema = cloneDeep(schema) as T & SchemaWithDefs;
+  // const inlinedSchema = JSON.parse(JSON.stringify(schema)) as T & SchemaWithDefs;
+  const collectedRefs = new Set<string>();
+
+  // Initialize $defs if it doesn't exist
+  if (!inlinedSchema.$defs) {
+    inlinedSchema.$defs = {};
+  }
+
+  /**
+   * Recursively traverse the schema to find all $ref references
+   */
+  function collectRefs(obj: unknown): void {
+    if (typeof obj !== "object" || obj === null) return;
+
+    if (Array.isArray(obj)) {
+      obj.forEach(collectRefs);
+      return;
+    }
+
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      if (key === "$ref" && typeof value === "string") {
+        // Extract the schema ID from the reference
+        if (!value.startsWith("#/")) {
+          collectedRefs.add(value);
+        }
+      } else {
+        collectRefs(value);
+      }
+    }
+  }
+
+  /**
+   * Convert external $ref to local $defs reference
+   */
+  function convertRefsToLocal(obj: unknown, refMap: Map<string, string>): unknown {
+    if (typeof obj !== "object" || obj === null) return obj;
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => convertRefsToLocal(item, refMap));
+    }
+
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      if (key === "$ref" && typeof value === "string") {
+        const localRef = refMap.get(value);
+        result[key] = localRef || value;
+      } else {
+        result[key] = convertRefsToLocal(value, refMap);
+      }
+    }
+    return result;
+  }
+
+  // Collect all references in the schema
+  collectRefs(inlinedSchema);
+
+  // Map to track original ref -> local def reference
+  const refToLocalMap = new Map<string, string>();
+
+  // Process each collected reference
+  for (const refId of collectedRefs) {
+    // Get the schema from AJV
+    const referencedSchema = ajv.getSchema(refId);
+
+    if (!referencedSchema?.schema) {
+      //   console.log(`Schema with ID "${refId}" not found in AJV instance`, { referencedSchema });
+      continue;
+    }
+
+    // Create a safe key for $defs (remove special characters, use last part of URI)
+    const defKey =
+      refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") ||
+      refId
+        .split("/")
+        .pop()
+        ?.replace(/[^a-zA-Z0-9_-]/g, "_") ||
+      `ref_${Object.keys(inlinedSchema.$defs!).length}`;
+
+    // Ensure unique key
+    let uniqueDefKey = defKey;
+    let counter = 1;
+    while (inlinedSchema.$defs![uniqueDefKey]) {
+      uniqueDefKey = `${defKey}_${counter}`;
+      counter++;
+    }
+
+    // Add to $defs
+    const { $id, ...schemaWithoutId } = referencedSchema.schema as TSchema;
+    inlinedSchema.$defs![uniqueDefKey] = schemaWithoutId;
+
+    // Map original reference to local reference
+    refToLocalMap.set(refId, `#/$defs/${uniqueDefKey}`);
+  }
+
+  // Convert all external references to local $defs references
+  const finalSchema = convertRefsToLocal(inlinedSchema, refToLocalMap) as T & SchemaWithDefs;
+
+  // Recursively inline references in the newly added $defs schemas
+  if (finalSchema.$defs) {
+    // Keep processing until no new references are found
+    let foundNewRefs = true;
+    while (foundNewRefs) {
+      foundNewRefs = false;
+      const newRefsFound = new Set<string>();
+
+      // Check each $defs schema for new references
+      for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
+        const defCollectedRefs = new Set<string>();
+
+        // Collect refs specifically for this schema
+        function collectDefsRefs(obj: unknown): void {
+          if (typeof obj !== "object" || obj === null) return;
+
+          if (Array.isArray(obj)) {
+            obj.forEach(collectDefsRefs);
+            return;
+          }
+
+          for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+            if (key === "$ref" && typeof value === "string") {
+              const refId = value.startsWith("#/") ? value : value;
+              if (!refId.startsWith("#/")) {
+                defCollectedRefs.add(refId);
+              }
+            } else {
+              collectDefsRefs(value);
+            }
+          }
+        }
+
+        collectDefsRefs(defSchema);
+
+        // Process any new references found in this $defs schema
+        for (const refId of defCollectedRefs) {
+          if (!refToLocalMap.has(refId)) {
+            newRefsFound.add(refId);
+            foundNewRefs = true;
+          }
+        }
+      }
+
+      // Add all newly found references to $defs
+      for (const refId of newRefsFound) {
+        const referencedSchema = ajv.getSchema(refId);
+        if (referencedSchema?.schema) {
+          const newDefKey =
+            refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") ||
+            `ref_${Object.keys(finalSchema.$defs).length}`;
+
+          let uniqueNewDefKey = newDefKey;
+          let counter = 1;
+          while (finalSchema.$defs[uniqueNewDefKey]) {
+            uniqueNewDefKey = `${newDefKey}_${counter}`;
+            counter++;
+          }
+
+          finalSchema.$defs[uniqueNewDefKey] = referencedSchema.schema as TSchema;
+          refToLocalMap.set(refId, `#/$defs/${uniqueNewDefKey}`);
+        }
+      }
+    }
+
+    // Finally, update all $defs schemas with converted references
+    for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
+      finalSchema.$defs[defKey] = convertRefsToLocal(defSchema, refToLocalMap) as TSchema;
+    }
+  }
+
+  return finalSchema as T & { $defs: Record<string, TSchema> };
+}

package/src/shared/utils/merge.ts

@@ -0,0 +1,12 @@
+import { mergeWith, isArray } from "lodash-es";
+
+export function mergeIgnoringArrays<T>(target: T, ...sources: T[]): T {
+  return mergeWith(target, ...sources, customizer);
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+function customizer(objValue: any, srcValue: any) {
+  if (isArray(objValue)) {
+    return srcValue;
+  }
+}

package/src/shared/utils/object-hash.ts

@@ -0,0 +1,7 @@
+export async function getObjectHash(obj: unknown): Promise<string> {
+  const str = JSON.stringify(obj);
+  const buffer = new TextEncoder().encode(str);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}