@ghostlytools/cli 1.11.3 → 1.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (218) hide show
  1. package/README.md +52 -30
  2. package/SKILL.md +4 -2
  3. package/dist/assets/{api-DBlaoz8i.js → api-DLzCtePC.js} +533 -195
  4. package/dist/assets/api-DLzCtePC.js.map +1 -0
  5. package/dist/assets/{api-DgU4MZPD.js → api-DYMKyb1k.js} +2 -2
  6. package/dist/assets/{apiKit-DesObIDf.js → apiKit-CVaEzKWQ.js} +104 -21
  7. package/dist/assets/apiKit-CVaEzKWQ.js.map +1 -0
  8. package/dist/assets/appFetch-D56GsYuq.js +602 -0
  9. package/dist/assets/appFetch-D56GsYuq.js.map +1 -0
  10. package/dist/assets/apps-BPFW19Wc.js +1 -0
  11. package/dist/assets/{apps-DkMjDHML.js → apps-XnZ8VEuj.js} +66 -38
  12. package/dist/assets/apps-XnZ8VEuj.js.map +1 -0
  13. package/dist/assets/{argon2id-088uQfnH.js → argon2id-B9wFdSj6.js} +2 -3
  14. package/dist/assets/{argon2id-088uQfnH.js.map → argon2id-B9wFdSj6.js.map} +1 -1
  15. package/dist/assets/{arkade-CarKONmH.js → arkade-DryM-q5n.js} +6 -7
  16. package/dist/assets/arkade-DryM-q5n.js.map +1 -0
  17. package/dist/assets/backup-COX6j1_W.js +1 -0
  18. package/dist/assets/{backup-C0OJCJlM.js → backup-DpyvT9Z6.js} +108 -50
  19. package/dist/assets/backup-DpyvT9Z6.js.map +1 -0
  20. package/dist/assets/bark_ffi_wasm_bg-CcafsJla.js +5 -0
  21. package/dist/assets/{bark_ffi_wasm_bg-EY2uc0Bx.js.map → bark_ffi_wasm_bg-CcafsJla.js.map} +1 -1
  22. package/dist/assets/{bark_ffi_wasm_bg-Bxru_BVW.wasm → bark_ffi_wasm_bg-VNmaJsc9.wasm} +0 -0
  23. package/dist/assets/{bitcoind-CdSmvy2y.js → bitcoind-DTsrd7TF.js} +4 -5
  24. package/dist/assets/{bitcoind-CdSmvy2y.js.map → bitcoind-DTsrd7TF.js.map} +1 -1
  25. package/dist/assets/bitcoindevkit_bg-BWQHx7vd.js +5 -0
  26. package/dist/assets/{bitcoindevkit_bg-B-iLWrmX.js.map → bitcoindevkit_bg-BWQHx7vd.js.map} +1 -1
  27. package/dist/assets/bitcoindevkit_bg-DXil67yS.wasm +0 -0
  28. package/dist/assets/{blobFiles-BmsrvZc3.js → blobFiles-DDs34n0r.js} +4 -5
  29. package/dist/assets/{blobFiles-BmsrvZc3.js.map → blobFiles-DDs34n0r.js.map} +1 -1
  30. package/dist/assets/breez_sdk_spark_wasm_bg.wasm +0 -0
  31. package/dist/assets/buttons-Bq7pTXqF.js +1 -0
  32. package/dist/assets/{buttons-fZTEa_2i.js → buttons-BvWqHJeh.js} +46 -23
  33. package/dist/assets/buttons-BvWqHJeh.js.map +1 -0
  34. package/dist/assets/bytes-C1DNGY18.js +132 -0
  35. package/dist/assets/bytes-C1DNGY18.js.map +1 -0
  36. package/dist/assets/{childEnv-K_IzUqQx.js → childEnv-C-99hdbL.js} +2 -3
  37. package/dist/assets/{childEnv-K_IzUqQx.js.map → childEnv-C-99hdbL.js.map} +1 -1
  38. package/dist/assets/{client-Ibk3-e60.js → client-kGZ3ZdUW.js} +30 -13
  39. package/dist/assets/client-kGZ3ZdUW.js.map +1 -0
  40. package/dist/assets/{codec-DMpQqVSt.js → codec-B2rH1mfx.js} +2 -4
  41. package/dist/assets/{codec-DMpQqVSt.js.map → codec-B2rH1mfx.js.map} +1 -1
  42. package/dist/assets/domainProofs-BDNP1dIy.js +280 -0
  43. package/dist/assets/domainProofs-BDNP1dIy.js.map +1 -0
  44. package/dist/assets/{endpoint-DarqblYE.js → endpoint-B0vE5ojY.js} +421 -420
  45. package/dist/assets/endpoint-B0vE5ojY.js.map +1 -0
  46. package/dist/assets/engineErrors--9hfgKlK.js +150 -0
  47. package/dist/assets/engineErrors--9hfgKlK.js.map +1 -0
  48. package/dist/assets/{envelope-CvQVCGdf.js → envelope-Bi2kMqbp.js} +3 -4
  49. package/dist/assets/{envelope-CvQVCGdf.js.map → envelope-Bi2kMqbp.js.map} +1 -1
  50. package/dist/assets/{errors-Dt-ZnyOX.js → errors-DDLFO4Gf.js} +31 -5
  51. package/dist/assets/errors-DDLFO4Gf.js.map +1 -0
  52. package/dist/assets/{fedimintSdk-zV_5Qdqz.js → fedimintSdk-D-6H9Pe7.js} +4 -5
  53. package/dist/assets/{fedimintSdk-zV_5Qdqz.js.map → fedimintSdk-D-6H9Pe7.js.map} +1 -1
  54. package/dist/assets/fedimint_client_wasm_bg-Cr5xGD-w.js +5 -0
  55. package/dist/assets/{fedimint_client_wasm_bg-BtHHlFpp.js.map → fedimint_client_wasm_bg-Cr5xGD-w.js.map} +1 -1
  56. package/dist/assets/fileBytes-CCKbwqG_.js +1 -0
  57. package/dist/assets/{fileBytes-BLPZq9YU.js → fileBytes-CfvUXdSy.js} +5 -7
  58. package/dist/assets/fileBytes-CfvUXdSy.js.map +1 -0
  59. package/dist/assets/{fileBytes-B0z9A6Le.js → fileBytes-tj6-VZcB.js} +3 -4
  60. package/dist/assets/{fileBytes-B0z9A6Le.js.map → fileBytes-tj6-VZcB.js.map} +1 -1
  61. package/dist/assets/fileBytesIdb-B0zzJ6p7.js +1 -0
  62. package/dist/assets/{fileBytesIdb-Bmlrl9EO.js → fileBytesIdb-BJirUAjI.js} +4 -5
  63. package/dist/assets/{fileBytesIdb-Bmlrl9EO.js.map → fileBytesIdb-BJirUAjI.js.map} +1 -1
  64. package/dist/assets/{fileBytesOpfs-DBS0kbPT.js → fileBytesOpfs-DRUYLER4.js} +4 -5
  65. package/dist/assets/{fileBytesOpfs-DBS0kbPT.js.map → fileBytesOpfs-DRUYLER4.js.map} +1 -1
  66. package/dist/assets/{fixedHosts-6gKn8dp2.js → fixedHosts-CPSsGOI2.js} +4 -5
  67. package/dist/assets/{fixedHosts-6gKn8dp2.js.map → fixedHosts-CPSsGOI2.js.map} +1 -1
  68. package/dist/assets/{ghostly_iroh_web-BzAXJUYH.js → ghostly_iroh_web-DIj5xGmR.js} +2 -3
  69. package/dist/assets/{ghostly_iroh_web-BzAXJUYH.js.map → ghostly_iroh_web-DIj5xGmR.js.map} +1 -1
  70. package/dist/assets/{src-DjVj2ynY.js → groupMeta-DTQAJG50.js} +4879 -23799
  71. package/dist/assets/groupMeta-DTQAJG50.js.map +1 -0
  72. package/dist/assets/{host-CYlIiY3r.js → host-z0FAHP9Z.js} +750 -245
  73. package/dist/assets/host-z0FAHP9Z.js.map +1 -0
  74. package/dist/assets/{hyperdhtRelay-CdsLcAhY.js → hyperdhtRelay-CvsAfQRQ.js} +5 -6
  75. package/dist/assets/hyperdhtRelay-CvsAfQRQ.js.map +1 -0
  76. package/dist/assets/hyperdhtRelay-bjNGacf5.js +32 -0
  77. package/dist/assets/hyperdhtRelay-bjNGacf5.js.map +1 -0
  78. package/dist/assets/{idb-CEuoNsTv.js → idb-ewvbqyDI.js} +2 -3
  79. package/dist/assets/{idb-CEuoNsTv.js.map → idb-ewvbqyDI.js.map} +1 -1
  80. package/dist/assets/identityProofs-Cksc_K7_.js +940 -0
  81. package/dist/assets/identityProofs-Cksc_K7_.js.map +1 -0
  82. package/dist/assets/{irohWeb-D2IuloLL.js → irohWeb-CLBx5MIv.js} +3061 -86
  83. package/dist/assets/irohWeb-CLBx5MIv.js.map +1 -0
  84. package/dist/assets/joinTrace-CBr1jbch.js +1 -0
  85. package/dist/assets/{joinTrace-CjRDFy85.js → joinTrace-xKBe73j9.js} +2 -3
  86. package/dist/assets/{joinTrace-CjRDFy85.js.map → joinTrace-xKBe73j9.js.map} +1 -1
  87. package/dist/assets/{legacy_ciphers-JJOu0JXL.js → legacy_ciphers-BnYATjxo.js} +2 -3
  88. package/dist/assets/{legacy_ciphers-JJOu0JXL.js.map → legacy_ciphers-BnYATjxo.js.map} +1 -1
  89. package/dist/assets/linkPreview-DdMf-YAc.js +252 -0
  90. package/dist/assets/linkPreview-DdMf-YAc.js.map +1 -0
  91. package/dist/assets/{main-C0PfjKTe.js → main-CVqkvuIo.js} +536 -173
  92. package/dist/assets/main-CVqkvuIo.js.map +1 -0
  93. package/dist/assets/{mainline-Cu61qcPS.js → mainline-CVrd0C1n.js} +72 -18
  94. package/dist/assets/mainline-CVrd0C1n.js.map +1 -0
  95. package/dist/assets/mints-BcBODVVW.js +1 -0
  96. package/dist/assets/{mints-j5XAOk4f.js → mints-CMDLbMeH.js} +8 -6
  97. package/dist/assets/mints-CMDLbMeH.js.map +1 -0
  98. package/dist/assets/{nacl-fast-CDhNCYHs.js → nacl-fast-B1ThWvuM.js} +2 -3
  99. package/dist/assets/{nacl-fast-CDhNCYHs.js.map → nacl-fast-B1ThWvuM.js.map} +1 -1
  100. package/dist/assets/{networkReason-Dt7Yx_n4.js → networkReason-Be-hMghr.js} +10 -14
  101. package/dist/assets/{networkReason-Dt7Yx_n4.js.map → networkReason-Be-hMghr.js.map} +1 -1
  102. package/dist/assets/{noble_curves-DDWn5AH0.js → noble_curves-DqpNlhAU.js} +3 -4
  103. package/dist/assets/{noble_curves-DDWn5AH0.js.map → noble_curves-DqpNlhAU.js.map} +1 -1
  104. package/dist/assets/{noble_hashes-B7AZyFyS.js → noble_hashes-LFe1N2xt.js} +3 -4
  105. package/dist/assets/{noble_hashes-B7AZyFyS.js.map → noble_hashes-LFe1N2xt.js.map} +1 -1
  106. package/dist/assets/{nwc-CtZypDcv.js → nwc-DKE2FXr6.js} +5 -6
  107. package/dist/assets/{nwc-CtZypDcv.js.map → nwc-DKE2FXr6.js.map} +1 -1
  108. package/dist/assets/nwcProvider-pL2XqSbW.js +208 -0
  109. package/dist/assets/nwcProvider-pL2XqSbW.js.map +1 -0
  110. package/dist/assets/{openpgp-BBFr-zHQ.js → openpgp-LkR_Zof0.js} +14 -15
  111. package/dist/assets/{openpgp-BBFr-zHQ.js.map → openpgp-LkR_Zof0.js.map} +1 -1
  112. package/dist/assets/ownDid-DY3rYqDI.js +862 -0
  113. package/dist/assets/ownDid-DY3rYqDI.js.map +1 -0
  114. package/dist/assets/{ownStatus-D4HC6tNR.js → ownStatus-DMEhrpkd.js} +81 -19
  115. package/dist/assets/ownStatus-DMEhrpkd.js.map +1 -0
  116. package/dist/assets/pairedTransports-BKmvlKz1.js +581 -0
  117. package/dist/assets/pairedTransports-BKmvlKz1.js.map +1 -0
  118. package/dist/assets/paymentIntent-DySU3Ajm.js +349 -0
  119. package/dist/assets/paymentIntent-DySU3Ajm.js.map +1 -0
  120. package/dist/assets/pkarr-BQo4PcCg.js +367 -0
  121. package/dist/assets/pkarr-BQo4PcCg.js.map +1 -0
  122. package/dist/assets/{profiles-Ccdq6Xf6.js → profiles-BFSGqDFC.js} +30 -16
  123. package/dist/assets/profiles-BFSGqDFC.js.map +1 -0
  124. package/dist/assets/registry-B15Yg_1C.js +1 -0
  125. package/dist/assets/{registry-LvxsLJ5S.js → registry-rXgaZeNn.js} +1273 -58
  126. package/dist/assets/registry-rXgaZeNn.js.map +1 -0
  127. package/dist/assets/relay-Cjfmdec0.js +2219 -0
  128. package/dist/assets/relay-Cjfmdec0.js.map +1 -0
  129. package/dist/assets/resolve-CIc3KZMV.js +970 -0
  130. package/dist/assets/resolve-CIc3KZMV.js.map +1 -0
  131. package/dist/assets/{restoredRows-C3LcxmOw.js → restoredRows-D_WSHE7H.js} +3 -4
  132. package/dist/assets/{restoredRows-C3LcxmOw.js.map → restoredRows-D_WSHE7H.js.map} +1 -1
  133. package/dist/assets/{secretGuard-B7Hj0Kvz.js → secretGuard-B4-LlMjv.js} +75 -16
  134. package/dist/assets/{secretGuard-B7Hj0Kvz.js.map → secretGuard-B4-LlMjv.js.map} +1 -1
  135. package/dist/assets/secretGuard-BmmnEbYf.js +1 -0
  136. package/dist/assets/{server-Q3VcNqGt.js → server-CQR7NLCz.js} +10200 -625
  137. package/dist/assets/server-CQR7NLCz.js.map +1 -0
  138. package/dist/assets/{sha512-BYId-G-T.js → sha512-DST9fbWH.js} +2 -3
  139. package/dist/assets/{sha512-BYId-G-T.js.map → sha512-DST9fbWH.js.map} +1 -1
  140. package/dist/assets/sshForges-BnvwmNj-.js +539 -0
  141. package/dist/assets/sshForges-BnvwmNj-.js.map +1 -0
  142. package/dist/assets/{storage-Bya5b2Xt.js → storage-BpjdxvO2.js} +243 -34
  143. package/dist/assets/storage-BpjdxvO2.js.map +1 -0
  144. package/dist/assets/text-li76pThX.js +106 -0
  145. package/dist/assets/text-li76pThX.js.map +1 -0
  146. package/dist/assets/{translate-iQZq4TnY.js → translate-BcbSWkuq.js} +21 -26
  147. package/dist/assets/{translate-iQZq4TnY.js.map → translate-BcbSWkuq.js.map} +1 -1
  148. package/dist/assets/{tree-store-N362nuzZ.js → tree-store-CAchkO_l.js} +22 -6
  149. package/dist/assets/tree-store-CAchkO_l.js.map +1 -0
  150. package/dist/assets/{types-Clyb52K2.js → types-CdWwgvyt.js} +2 -3
  151. package/dist/assets/{types-Clyb52K2.js.map → types-CdWwgvyt.js.map} +1 -1
  152. package/dist/assets/{unbzip2-stream-B1C-JX9L.js → unbzip2-stream-BtkYGpC5.js} +2 -3
  153. package/dist/assets/{unbzip2-stream-B1C-JX9L.js.map → unbzip2-stream-BtkYGpC5.js.map} +1 -1
  154. package/dist/assets/{usdt-DnyTGdTX.js → usdt-CBJ4Q5Ji.js} +7 -7
  155. package/dist/assets/usdt-CBJ4Q5Ji.js.map +1 -0
  156. package/dist/assets/{waitNotice-Cn0WJ-He.js → waitNotice-BGM0QOS2.js} +27 -4
  157. package/dist/assets/waitNotice-BGM0QOS2.js.map +1 -0
  158. package/dist/assets/{web-DwgdhfcY.js → web-68CYFCl9.js} +314 -91
  159. package/dist/assets/web-68CYFCl9.js.map +1 -0
  160. package/dist/ghostly.mjs +3 -5
  161. package/dist/ghostly.mjs.map +1 -1
  162. package/npm-shrinkwrap.json +225 -200
  163. package/package.json +16 -16
  164. package/dist/assets/api-DBlaoz8i.js.map +0 -1
  165. package/dist/assets/apiKit-DesObIDf.js.map +0 -1
  166. package/dist/assets/appFetch-C8yZIq1e.js +0 -194
  167. package/dist/assets/appFetch-C8yZIq1e.js.map +0 -1
  168. package/dist/assets/apps-DkMjDHML.js.map +0 -1
  169. package/dist/assets/apps-rzxsjfBV.js +0 -2
  170. package/dist/assets/arkade-CarKONmH.js.map +0 -1
  171. package/dist/assets/backup-C0OJCJlM.js.map +0 -1
  172. package/dist/assets/backup-CgWU7x0T.js +0 -2
  173. package/dist/assets/bark_ffi_wasm_bg-EY2uc0Bx.js +0 -6
  174. package/dist/assets/bitcoindProvider-BvoRh0D5.js +0 -97
  175. package/dist/assets/bitcoindProvider-BvoRh0D5.js.map +0 -1
  176. package/dist/assets/bitcoindevkit_bg-B-iLWrmX.js +0 -6
  177. package/dist/assets/bitcoindevkit_bg-CRkZTSbO.wasm +0 -0
  178. package/dist/assets/buttons-Cco0Agfa.js +0 -2
  179. package/dist/assets/buttons-fZTEa_2i.js.map +0 -1
  180. package/dist/assets/client-Ibk3-e60.js.map +0 -1
  181. package/dist/assets/endpoint-DarqblYE.js.map +0 -1
  182. package/dist/assets/errors-Dt-ZnyOX.js.map +0 -1
  183. package/dist/assets/fedimint_client_wasm_bg-BtHHlFpp.js +0 -6
  184. package/dist/assets/fileBytes-BLPZq9YU.js.map +0 -1
  185. package/dist/assets/fileBytes-BtIyoDF2.js +0 -2
  186. package/dist/assets/fileBytesIdb-D8mAK4pF.js +0 -2
  187. package/dist/assets/host-CYlIiY3r.js.map +0 -1
  188. package/dist/assets/hyperdhtRelay-1wzya_0L.js +0 -25
  189. package/dist/assets/hyperdhtRelay-1wzya_0L.js.map +0 -1
  190. package/dist/assets/hyperdhtRelay-CdsLcAhY.js.map +0 -1
  191. package/dist/assets/irohWeb-D2IuloLL.js.map +0 -1
  192. package/dist/assets/joinTrace-D-fnt2p3.js +0 -2
  193. package/dist/assets/jsonOut-POtMBS_V.js +0 -16
  194. package/dist/assets/jsonOut-POtMBS_V.js.map +0 -1
  195. package/dist/assets/main-C0PfjKTe.js.map +0 -1
  196. package/dist/assets/mainline-Cu61qcPS.js.map +0 -1
  197. package/dist/assets/mints-BaOmx517.js +0 -2
  198. package/dist/assets/mints-j5XAOk4f.js.map +0 -1
  199. package/dist/assets/nwcProvider-DYHkd0iu.js +0 -88
  200. package/dist/assets/nwcProvider-DYHkd0iu.js.map +0 -1
  201. package/dist/assets/ownDid-CJ0ta8CL.js +0 -282
  202. package/dist/assets/ownDid-CJ0ta8CL.js.map +0 -1
  203. package/dist/assets/ownStatus-D4HC6tNR.js.map +0 -1
  204. package/dist/assets/profiles-Ccdq6Xf6.js.map +0 -1
  205. package/dist/assets/registry-CE0PpQAE.js +0 -2
  206. package/dist/assets/registry-LvxsLJ5S.js.map +0 -1
  207. package/dist/assets/resolve-6kVu2DE5.js +0 -400
  208. package/dist/assets/resolve-6kVu2DE5.js.map +0 -1
  209. package/dist/assets/secretGuard-DUr6bgKc.js +0 -2
  210. package/dist/assets/server-Q3VcNqGt.js.map +0 -1
  211. package/dist/assets/src-DjVj2ynY.js.map +0 -1
  212. package/dist/assets/sshForges-DeZ9cN9Q.js +0 -261
  213. package/dist/assets/sshForges-DeZ9cN9Q.js.map +0 -1
  214. package/dist/assets/storage-Bya5b2Xt.js.map +0 -1
  215. package/dist/assets/tree-store-N362nuzZ.js.map +0 -1
  216. package/dist/assets/usdt-DnyTGdTX.js.map +0 -1
  217. package/dist/assets/waitNotice-Cn0WJ-He.js.map +0 -1
  218. package/dist/assets/web-DwgdhfcY.js.map +0 -1
@@ -1,12 +1,12 @@
1
1
  import { createRequire } from "node:module";
2
- //#region \0rolldown/runtime.js
2
+ // \0rolldown/runtime.js
3
3
  var __create = Object.create;
4
4
  var __defProp = Object.defineProperty;
5
5
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
6
6
  var __getOwnPropNames = Object.getOwnPropertyNames;
7
7
  var __getProtoOf = Object.getPrototypeOf;
8
8
  var __hasOwnProp = Object.prototype.hasOwnProperty;
9
- var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
9
+ var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
10
10
  var __copyProps = (to, from, except, desc) => {
11
11
  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
12
12
  key = keys[i];
@@ -22,56 +22,55 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
22
22
  enumerable: true
23
23
  }) : target, mod));
24
24
  var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
25
- //#endregion
26
- //#region ../../node_modules/hyperdht/lib/messages.js
25
+ // ../../node_modules/hyperdht/lib/messages.js
27
26
  var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
28
- var c$5 = __require("compact-encoding");
27
+ var c = __require("compact-encoding");
29
28
  var ipv4 = {
30
- ...c$5.ipv4Address,
29
+ ...c.ipv4Address,
31
30
  decode(state) {
32
- const ip = c$5.ipv4Address.decode(state);
31
+ const ip = c.ipv4Address.decode(state);
33
32
  return {
34
33
  host: ip.host,
35
34
  port: ip.port
36
35
  };
37
36
  }
38
37
  };
39
- var ipv4Array = c$5.array(ipv4);
38
+ var ipv4Array = c.array(ipv4);
40
39
  var ipv6 = {
41
- ...c$5.ipv6Address,
40
+ ...c.ipv6Address,
42
41
  decode(state) {
43
- const ip = c$5.ipv6Address.decode(state);
42
+ const ip = c.ipv6Address.decode(state);
44
43
  return {
45
44
  host: ip.host,
46
45
  port: ip.port
47
46
  };
48
47
  }
49
48
  };
50
- var ipv6Array = c$5.array(ipv6);
49
+ var ipv6Array = c.array(ipv6);
51
50
  exports.handshake = {
52
51
  preencode(state, m) {
53
52
  state.end += 2 + (m.peerAddress ? 6 : 0) + (m.relayAddress ? 6 : 0);
54
- c$5.buffer.preencode(state, m.noise);
53
+ c.buffer.preencode(state, m.noise);
55
54
  },
56
55
  encode(state, m) {
57
56
  const flags = (m.peerAddress ? 1 : 0) | (m.relayAddress ? 2 : 0);
58
- c$5.uint.encode(state, flags);
59
- c$5.uint.encode(state, m.mode);
60
- c$5.buffer.encode(state, m.noise);
57
+ c.uint.encode(state, flags);
58
+ c.uint.encode(state, m.mode);
59
+ c.buffer.encode(state, m.noise);
61
60
  if (m.peerAddress) ipv4.encode(state, m.peerAddress);
62
61
  if (m.relayAddress) ipv4.encode(state, m.relayAddress);
63
62
  },
64
63
  decode(state) {
65
- const flags = c$5.uint.decode(state);
64
+ const flags = c.uint.decode(state);
66
65
  return {
67
- mode: c$5.uint.decode(state),
68
- noise: c$5.buffer.decode(state),
66
+ mode: c.uint.decode(state),
67
+ noise: c.buffer.decode(state),
69
68
  peerAddress: flags & 1 ? ipv4.decode(state) : null,
70
69
  relayAddress: flags & 2 ? ipv4.decode(state) : null
71
70
  };
72
71
  }
73
72
  };
74
- var relayInfoArray = c$5.array({
73
+ var relayInfoArray = c.array({
75
74
  preencode(state, m) {
76
75
  state.end += 12;
77
76
  },
@@ -88,16 +87,16 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
88
87
  });
89
88
  var holepunchInfo = {
90
89
  preencode(state, m) {
91
- c$5.uint.preencode(state, m.id);
90
+ c.uint.preencode(state, m.id);
92
91
  relayInfoArray.preencode(state, m.relays);
93
92
  },
94
93
  encode(state, m) {
95
- c$5.uint.encode(state, m.id);
94
+ c.uint.encode(state, m.id);
96
95
  relayInfoArray.encode(state, m.relays);
97
96
  },
98
97
  decode(state) {
99
98
  return {
100
- id: c$5.uint.decode(state),
99
+ id: c.uint.decode(state),
101
100
  relays: relayInfoArray.decode(state)
102
101
  };
103
102
  }
@@ -105,55 +104,55 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
105
104
  var udxInfo = {
106
105
  preencode(state, m) {
107
106
  state.end += 2;
108
- c$5.uint.preencode(state, m.id);
109
- c$5.uint.preencode(state, m.seq);
107
+ c.uint.preencode(state, m.id);
108
+ c.uint.preencode(state, m.seq);
110
109
  },
111
110
  encode(state, m) {
112
- c$5.uint.encode(state, 1);
113
- c$5.uint.encode(state, m.reusableSocket ? 1 : 0);
114
- c$5.uint.encode(state, m.id);
115
- c$5.uint.encode(state, m.seq);
111
+ c.uint.encode(state, 1);
112
+ c.uint.encode(state, m.reusableSocket ? 1 : 0);
113
+ c.uint.encode(state, m.id);
114
+ c.uint.encode(state, m.seq);
116
115
  },
117
116
  decode(state) {
118
117
  return {
119
- version: c$5.uint.decode(state),
120
- reusableSocket: (c$5.uint.decode(state) & 1) !== 0,
121
- id: c$5.uint.decode(state),
122
- seq: c$5.uint.decode(state)
118
+ version: c.uint.decode(state),
119
+ reusableSocket: (c.uint.decode(state) & 1) !== 0,
120
+ id: c.uint.decode(state),
121
+ seq: c.uint.decode(state)
123
122
  };
124
123
  }
125
124
  };
126
125
  var secretStreamInfo = {
127
126
  preencode(state, m) {
128
- c$5.uint.preencode(state, 1);
127
+ c.uint.preencode(state, 1);
129
128
  },
130
129
  encode(state, m) {
131
- c$5.uint.encode(state, 1);
130
+ c.uint.encode(state, 1);
132
131
  },
133
132
  decode(state) {
134
- return { version: c$5.uint.decode(state) };
133
+ return { version: c.uint.decode(state) };
135
134
  }
136
135
  };
137
136
  var relayThroughInfo = {
138
137
  preencode(state, m) {
139
- c$5.uint.preencode(state, 1);
140
- c$5.uint.preencode(state, 0);
141
- c$5.fixed32.preencode(state, m.publicKey);
142
- c$5.fixed32.preencode(state, m.token);
138
+ c.uint.preencode(state, 1);
139
+ c.uint.preencode(state, 0);
140
+ c.fixed32.preencode(state, m.publicKey);
141
+ c.fixed32.preencode(state, m.token);
143
142
  },
144
143
  encode(state, m) {
145
- c$5.uint.encode(state, 1);
146
- c$5.uint.encode(state, 0);
147
- c$5.fixed32.encode(state, m.publicKey);
148
- c$5.fixed32.encode(state, m.token);
144
+ c.uint.encode(state, 1);
145
+ c.uint.encode(state, 0);
146
+ c.fixed32.encode(state, m.publicKey);
147
+ c.fixed32.encode(state, m.token);
149
148
  },
150
149
  decode(state) {
151
- const version = c$5.uint.decode(state);
152
- c$5.uint.decode(state);
150
+ const version = c.uint.decode(state);
151
+ c.uint.decode(state);
153
152
  return {
154
153
  version,
155
- publicKey: c$5.fixed32.decode(state),
156
- token: c$5.fixed32.decode(state)
154
+ publicKey: c.fixed32.decode(state),
155
+ token: c.fixed32.decode(state)
157
156
  };
158
157
  }
159
158
  };
@@ -177,10 +176,10 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
177
176
  if (m.secretStream) flags |= 16;
178
177
  if (m.relayThrough) flags |= 32;
179
178
  if (m.relayAddresses) flags |= 64;
180
- c$5.uint.encode(state, 1);
181
- c$5.uint.encode(state, flags);
182
- c$5.uint.encode(state, m.error);
183
- c$5.uint.encode(state, m.firewall);
179
+ c.uint.encode(state, 1);
180
+ c.uint.encode(state, flags);
181
+ c.uint.encode(state, m.error);
182
+ c.uint.encode(state, m.firewall);
184
183
  if (m.holepunch) holepunchInfo.encode(state, m.holepunch);
185
184
  if (m.addresses4 && m.addresses4.length) ipv4Array.encode(state, m.addresses4);
186
185
  if (m.addresses6 && m.addresses6.length) ipv6Array.encode(state, m.addresses6);
@@ -190,7 +189,7 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
190
189
  if (m.relayAddresses) ipv4Array.encode(state, m.relayAddresses);
191
190
  },
192
191
  decode(state) {
193
- const version = c$5.uint.decode(state);
192
+ const version = c.uint.decode(state);
194
193
  if (version !== 1) return {
195
194
  version,
196
195
  error: 0,
@@ -203,11 +202,11 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
203
202
  relayThrough: null,
204
203
  relayAddresses: null
205
204
  };
206
- const flags = c$5.uint.decode(state);
205
+ const flags = c.uint.decode(state);
207
206
  return {
208
207
  version,
209
- error: c$5.uint.decode(state),
210
- firewall: c$5.uint.decode(state),
208
+ error: c.uint.decode(state),
209
+ firewall: c.uint.decode(state),
211
210
  holepunch: (flags & 1) !== 0 ? holepunchInfo.decode(state) : null,
212
211
  addresses4: (flags & 2) !== 0 ? ipv4Array.decode(state) : [],
213
212
  addresses6: (flags & 4) !== 0 ? ipv6Array.decode(state) : [],
@@ -221,24 +220,24 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
221
220
  exports.holepunch = {
222
221
  preencode(state, m) {
223
222
  state.end += 2;
224
- c$5.uint.preencode(state, m.id);
225
- c$5.buffer.preencode(state, m.payload);
223
+ c.uint.preencode(state, m.id);
224
+ c.buffer.preencode(state, m.payload);
226
225
  if (m.peerAddress) ipv4.preencode(state, m.peerAddress);
227
226
  },
228
227
  encode(state, m) {
229
228
  const flags = m.peerAddress ? 1 : 0;
230
- c$5.uint.encode(state, flags);
231
- c$5.uint.encode(state, m.mode);
232
- c$5.uint.encode(state, m.id);
233
- c$5.buffer.encode(state, m.payload);
229
+ c.uint.encode(state, flags);
230
+ c.uint.encode(state, m.mode);
231
+ c.uint.encode(state, m.id);
232
+ c.buffer.encode(state, m.payload);
234
233
  if (m.peerAddress) ipv4.encode(state, m.peerAddress);
235
234
  },
236
235
  decode(state) {
237
- const flags = c$5.uint.decode(state);
236
+ const flags = c.uint.decode(state);
238
237
  return {
239
- mode: c$5.uint.decode(state),
240
- id: c$5.uint.decode(state),
241
- payload: c$5.buffer.decode(state),
238
+ mode: c.uint.decode(state),
239
+ id: c.uint.decode(state),
240
+ payload: c.buffer.decode(state),
242
241
  peerAddress: flags & 1 ? ipv4.decode(state) : null
243
242
  };
244
243
  }
@@ -253,27 +252,27 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
253
252
  },
254
253
  encode(state, m) {
255
254
  const flags = (m.connected ? 1 : 0) | (m.punching ? 2 : 0) | (m.addresses ? 4 : 0) | (m.remoteAddress ? 8 : 0) | (m.token ? 16 : 0) | (m.remoteToken ? 32 : 0);
256
- c$5.uint.encode(state, flags);
257
- c$5.uint.encode(state, m.error);
258
- c$5.uint.encode(state, m.firewall);
259
- c$5.uint.encode(state, m.round);
255
+ c.uint.encode(state, flags);
256
+ c.uint.encode(state, m.error);
257
+ c.uint.encode(state, m.firewall);
258
+ c.uint.encode(state, m.round);
260
259
  if (m.addresses) ipv4Array.encode(state, m.addresses);
261
260
  if (m.remoteAddress) ipv4.encode(state, m.remoteAddress);
262
- if (m.token) c$5.fixed32.encode(state, m.token);
263
- if (m.remoteToken) c$5.fixed32.encode(state, m.remoteToken);
261
+ if (m.token) c.fixed32.encode(state, m.token);
262
+ if (m.remoteToken) c.fixed32.encode(state, m.remoteToken);
264
263
  },
265
264
  decode(state) {
266
- const flags = c$5.uint.decode(state);
265
+ const flags = c.uint.decode(state);
267
266
  return {
268
- error: c$5.uint.decode(state),
269
- firewall: c$5.uint.decode(state),
270
- round: c$5.uint.decode(state),
267
+ error: c.uint.decode(state),
268
+ firewall: c.uint.decode(state),
269
+ round: c.uint.decode(state),
271
270
  connected: (flags & 1) !== 0,
272
271
  punching: (flags & 2) !== 0,
273
272
  addresses: (flags & 4) !== 0 ? ipv4Array.decode(state) : null,
274
273
  remoteAddress: (flags & 8) !== 0 ? ipv4.decode(state) : null,
275
- token: (flags & 16) !== 0 ? c$5.fixed32.decode(state) : null,
276
- remoteToken: (flags & 32) !== 0 ? c$5.fixed32.decode(state) : null
274
+ token: (flags & 16) !== 0 ? c.fixed32.decode(state) : null,
275
+ remoteToken: (flags & 32) !== 0 ? c.fixed32.decode(state) : null
277
276
  };
278
277
  }
279
278
  };
@@ -283,31 +282,31 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
283
282
  ipv4Array.preencode(state, m.relayAddresses);
284
283
  },
285
284
  encode(state, m) {
286
- c$5.fixed32.encode(state, m.publicKey);
285
+ c.fixed32.encode(state, m.publicKey);
287
286
  ipv4Array.encode(state, m.relayAddresses);
288
287
  },
289
288
  decode(state) {
290
289
  return {
291
- publicKey: c$5.fixed32.decode(state),
290
+ publicKey: c.fixed32.decode(state),
292
291
  relayAddresses: ipv4Array.decode(state)
293
292
  };
294
293
  }
295
294
  };
296
- var peers = exports.peers = c$5.array(peer);
297
- var rawPeers = c$5.array(c$5.raw);
295
+ var peers = exports.peers = c.array(peer);
296
+ var rawPeers = c.array(c.raw);
298
297
  exports.lookupRawReply = {
299
298
  preencode(state, m) {
300
299
  rawPeers.preencode(state, m.peers);
301
- c$5.uint.preencode(state, m.bump);
300
+ c.uint.preencode(state, m.bump);
302
301
  },
303
302
  encode(state, m) {
304
303
  rawPeers.encode(state, m.peers);
305
- c$5.uint.encode(state, m.bump);
304
+ c.uint.encode(state, m.bump);
306
305
  },
307
306
  decode(state) {
308
307
  return {
309
308
  peers: peers.decode(state),
310
- bump: state.start < state.end ? c$5.uint.decode(state) : 0
309
+ bump: state.start < state.end ? c.uint.decode(state) : 0
311
310
  };
312
311
  }
313
312
  };
@@ -317,113 +316,113 @@ var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
317
316
  if (m.peer) peer.preencode(state, m.peer);
318
317
  if (m.refresh) state.end += 32;
319
318
  if (m.signature) state.end += 64;
320
- if (m.bump) c$5.uint.preencode(state, m.bump);
319
+ if (m.bump) c.uint.preencode(state, m.bump);
321
320
  },
322
321
  encode(state, m) {
323
- const flags = (m.peer ? 1 : 0) | (m.refresh ? 2 : 0) | (m.signature ? 4 : 0) | (m.bump ? 8 : 0);
324
- c$5.uint.encode(state, flags);
322
+ const flags = (m.peer ? 1 : 0) | (m.refresh ? 2 : 0) | (m.signature ? 4 : 0) | (m.bump ? 8 : 0) | (m.lookup ? 16 : 0);
323
+ c.uint.encode(state, flags);
325
324
  if (m.peer) peer.encode(state, m.peer);
326
- if (m.refresh) c$5.fixed32.encode(state, m.refresh);
327
- if (m.signature) c$5.fixed64.encode(state, m.signature);
328
- if (m.bump) c$5.uint.encode(state, m.bump);
325
+ if (m.refresh) c.fixed32.encode(state, m.refresh);
326
+ if (m.signature) c.fixed64.encode(state, m.signature);
327
+ if (m.bump) c.uint.encode(state, m.bump);
329
328
  },
330
329
  decode(state) {
331
- const flags = c$5.uint.decode(state);
330
+ const flags = c.uint.decode(state);
332
331
  return {
333
332
  peer: (flags & 1) !== 0 ? peer.decode(state) : null,
334
- refresh: (flags & 2) !== 0 ? c$5.fixed32.decode(state) : null,
335
- signature: (flags & 4) !== 0 ? c$5.fixed64.decode(state) : null,
336
- bump: (flags & 8) !== 0 ? c$5.uint.decode(state) : 0
333
+ refresh: (flags & 2) !== 0 ? c.fixed32.decode(state) : null,
334
+ signature: (flags & 4) !== 0 ? c.fixed64.decode(state) : null,
335
+ bump: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
336
+ lookup: (flags & 16) !== 0
337
337
  };
338
338
  }
339
339
  };
340
340
  exports.mutableSignable = {
341
341
  preencode(state, m) {
342
- c$5.uint.preencode(state, m.seq);
343
- c$5.buffer.preencode(state, m.value);
342
+ c.uint.preencode(state, m.seq);
343
+ c.buffer.preencode(state, m.value);
344
344
  },
345
345
  encode(state, m) {
346
- c$5.uint.encode(state, m.seq);
347
- c$5.buffer.encode(state, m.value);
346
+ c.uint.encode(state, m.seq);
347
+ c.buffer.encode(state, m.value);
348
348
  },
349
349
  decode(state) {
350
350
  return {
351
- seq: c$5.uint.decode(state),
352
- value: c$5.buffer.decode(state)
351
+ seq: c.uint.decode(state),
352
+ value: c.buffer.decode(state)
353
353
  };
354
354
  }
355
355
  };
356
356
  exports.mutablePutRequest = {
357
357
  preencode(state, m) {
358
- c$5.fixed32.preencode(state, m.publicKey);
359
- c$5.uint.preencode(state, m.seq);
360
- c$5.buffer.preencode(state, m.value);
361
- c$5.fixed64.preencode(state, m.signature);
358
+ c.fixed32.preencode(state, m.publicKey);
359
+ c.uint.preencode(state, m.seq);
360
+ c.buffer.preencode(state, m.value);
361
+ c.fixed64.preencode(state, m.signature);
362
362
  },
363
363
  encode(state, m) {
364
- c$5.fixed32.encode(state, m.publicKey);
365
- c$5.uint.encode(state, m.seq);
366
- c$5.buffer.encode(state, m.value);
367
- c$5.fixed64.encode(state, m.signature);
364
+ c.fixed32.encode(state, m.publicKey);
365
+ c.uint.encode(state, m.seq);
366
+ c.buffer.encode(state, m.value);
367
+ c.fixed64.encode(state, m.signature);
368
368
  },
369
369
  decode(state) {
370
370
  return {
371
- publicKey: c$5.fixed32.decode(state),
372
- seq: c$5.uint.decode(state),
373
- value: c$5.buffer.decode(state),
374
- signature: c$5.fixed64.decode(state)
371
+ publicKey: c.fixed32.decode(state),
372
+ seq: c.uint.decode(state),
373
+ value: c.buffer.decode(state),
374
+ signature: c.fixed64.decode(state)
375
375
  };
376
376
  }
377
377
  };
378
378
  exports.mutableGetResponse = {
379
379
  preencode(state, m) {
380
- c$5.uint.preencode(state, m.seq);
381
- c$5.buffer.preencode(state, m.value);
382
- c$5.fixed64.preencode(state, m.signature);
380
+ c.uint.preencode(state, m.seq);
381
+ c.buffer.preencode(state, m.value);
382
+ c.fixed64.preencode(state, m.signature);
383
383
  },
384
384
  encode(state, m) {
385
- c$5.uint.encode(state, m.seq);
386
- c$5.buffer.encode(state, m.value);
387
- c$5.fixed64.encode(state, m.signature);
385
+ c.uint.encode(state, m.seq);
386
+ c.buffer.encode(state, m.value);
387
+ c.fixed64.encode(state, m.signature);
388
388
  },
389
389
  decode(state) {
390
390
  return {
391
- seq: c$5.uint.decode(state),
392
- value: c$5.buffer.decode(state),
393
- signature: c$5.fixed64.decode(state)
391
+ seq: c.uint.decode(state),
392
+ value: c.buffer.decode(state),
393
+ signature: c.fixed64.decode(state)
394
394
  };
395
395
  }
396
396
  };
397
397
  exports.pluginRequest = {
398
398
  preencode(state, m) {
399
- c$5.string.preencode(state, m.plugin);
400
- c$5.uint.preencode(state, m.version);
401
- c$5.uint.preencode(state, m.command);
399
+ c.string.preencode(state, m.plugin);
400
+ c.uint.preencode(state, m.version);
401
+ c.uint.preencode(state, m.command);
402
402
  state.end++;
403
- if (m.value) c$5.buffer.preencode(state, m.value);
403
+ if (m.value) c.buffer.preencode(state, m.value);
404
404
  },
405
405
  encode(state, m) {
406
406
  const flags = m.value ? 1 : 0;
407
- c$5.string.encode(state, m.plugin);
408
- c$5.uint.encode(state, m.version);
409
- c$5.uint.encode(state, m.command);
410
- c$5.uint.encode(state, flags);
411
- if (m.value) c$5.buffer.encode(state, m.value);
407
+ c.string.encode(state, m.plugin);
408
+ c.uint.encode(state, m.version);
409
+ c.uint.encode(state, m.command);
410
+ c.uint.encode(state, flags);
411
+ if (m.value) c.buffer.encode(state, m.value);
412
412
  },
413
413
  decode(state) {
414
414
  return {
415
- plugin: c$5.string.decode(state),
416
- version: c$5.uint.decode(state),
417
- command: c$5.uint.decode(state),
418
- value: (c$5.uint.decode(state) & 1) !== 0 ? c$5.buffer.decode(state) : null
415
+ plugin: c.string.decode(state),
416
+ version: c.uint.decode(state),
417
+ command: c.uint.decode(state),
418
+ value: (c.uint.decode(state) & 1) !== 0 ? c.buffer.decode(state) : null
419
419
  };
420
420
  }
421
421
  };
422
422
  }));
423
- //#endregion
424
- //#region ../../node_modules/hyperdht/lib/socket-pool.js
423
+ // ../../node_modules/hyperdht/lib/socket-pool.js
425
424
  var require_socket_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
426
- var b4a$18 = __require("b4a");
425
+ var b4a = __require("b4a");
427
426
  var LINGER_TIME = 3e3;
428
427
  module.exports = class SocketPool {
429
428
  constructor(dht, host) {
@@ -478,13 +477,13 @@ var require_socket_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
478
477
  else rawStream.on("connect", this._onconnect.bind(this, publicKey, rawStream));
479
478
  }
480
479
  get(publicKey) {
481
- const id = b4a$18.toString(publicKey, "hex");
480
+ const id = b4a.toString(publicKey, "hex");
482
481
  const route = this._routes.get(id);
483
482
  if (!route) return null;
484
483
  return route;
485
484
  }
486
485
  _onconnect(publicKey, rawStream) {
487
- const id = b4a$18.toString(publicKey, "hex");
486
+ const id = b4a.toString(publicKey, "hex");
488
487
  const socket = rawStream.socket;
489
488
  let route = this._routes.get(id);
490
489
  if (!route) {
@@ -592,22 +591,20 @@ var require_socket_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
592
591
  };
593
592
  function noop() {}
594
593
  }));
595
- //#endregion
596
- //#region ../../node_modules/hyperdht/lib/encode.js
594
+ // ../../node_modules/hyperdht/lib/encode.js
597
595
  var require_encode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
598
- var b4a$17 = __require("b4a");
596
+ var b4a = __require("b4a");
599
597
  var cenc = __require("compact-encoding");
600
598
  function encodeUnslab(enc, m) {
601
599
  const state = cenc.state();
602
600
  enc.preencode(state, m);
603
- state.buffer = b4a$17.allocUnsafeSlow(state.end);
601
+ state.buffer = b4a.allocUnsafeSlow(state.end);
604
602
  enc.encode(state, m);
605
603
  return state.buffer;
606
604
  }
607
605
  module.exports = { encodeUnslab };
608
606
  }));
609
- //#endregion
610
- //#region ../../node_modules/hyperdht/lib/constants.js
607
+ // ../../node_modules/hyperdht/lib/constants.js
611
608
  var require_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
612
609
  var crypto = __require("hypercore-crypto");
613
610
  var COMMANDS = exports.COMMANDS = {
@@ -659,41 +656,42 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
659
656
  PLUGIN: NS_PLUGIN
660
657
  };
661
658
  }));
662
- //#endregion
663
- //#region ../../node_modules/hyperdht/lib/persistent.js
659
+ // ../../node_modules/hyperdht/lib/persistent.js
664
660
  var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
665
- var c$4 = __require("compact-encoding");
666
- var sodium$6 = __require("sodium-universal");
661
+ var c = __require("compact-encoding");
662
+ var sodium = __require("sodium-universal");
667
663
  var RecordCache = __require("record-cache");
668
- var Cache$2 = __require("xache");
669
- var b4a$16 = __require("b4a");
670
- var unslab$1 = __require("unslab");
664
+ var Cache = __require("xache");
665
+ var b4a = __require("b4a");
666
+ var unslab = __require("unslab");
671
667
  var { encodeUnslab } = require_encode();
672
668
  var m = require_messages();
673
669
  var { NS, ERROR } = require_constants();
674
- var EMPTY = b4a$16.alloc(0);
675
- var TMP = b4a$16.allocUnsafe(32);
670
+ var EMPTY = b4a.alloc(0);
671
+ var TMP = b4a.allocUnsafe(32);
676
672
  var MAX_BUMP_DRIFT = 6e4;
677
673
  module.exports = class Persistent {
678
674
  constructor(dht, opts) {
679
675
  this.dht = dht;
680
676
  this.records = new RecordCache(opts.records);
681
- this.bumps = new Cache$2(opts.bumps);
682
- this.refreshes = new Cache$2(opts.refreshes);
683
- this.mutables = new Cache$2(opts.mutables);
684
- this.immutables = new Cache$2(opts.immutables);
677
+ this.bumps = new Cache(opts.bumps);
678
+ this.refreshes = new Cache(opts.refreshes);
679
+ this.mutables = new Cache(opts.mutables);
680
+ this.immutables = new Cache(opts.immutables);
685
681
  }
686
682
  onlookup(req) {
687
683
  if (!req.target) return;
688
- const k = b4a$16.toString(req.target, "hex");
684
+ req.reply(this._lookupReply(b4a.toString(req.target, "hex")));
685
+ }
686
+ _lookupReply(k) {
689
687
  const records = this.records.get(k, 20);
690
688
  const bump = this.bumps.get(k) || 0;
691
689
  const fwd = this.dht._router.get(k);
692
690
  if (fwd && records.length < 20) records.push(fwd.record);
693
- req.reply(records.length ? c$4.encode(m.lookupRawReply, {
691
+ return records.length ? c.encode(m.lookupRawReply, {
694
692
  peers: records,
695
693
  bump
696
- }) : null);
694
+ }) : null;
697
695
  }
698
696
  onfindpeer(req) {
699
697
  if (!req.target) return;
@@ -701,9 +699,9 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
701
699
  req.reply(fwd ? fwd.record : null);
702
700
  }
703
701
  unannounce(target, publicKey) {
704
- const k = b4a$16.toString(target, "hex");
705
- sodium$6.crypto_generichash(TMP, publicKey);
706
- if (b4a$16.equals(TMP, target)) this.dht._router.delete(k);
702
+ const k = b4a.toString(target, "hex");
703
+ sodium.crypto_generichash(TMP, publicKey);
704
+ if (b4a.equals(TMP, target)) this.dht._router.delete(k);
707
705
  this.records.remove(k, publicKey);
708
706
  }
709
707
  onunannounce(req) {
@@ -713,7 +711,7 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
713
711
  const { peer, signature } = unann;
714
712
  if (!peer || !signature) return;
715
713
  const signable = annSignable(req.target, req.token, this.dht.id, unann, NS.UNANNOUNCE);
716
- if (!sodium$6.crypto_sign_verify_detached(signature, signable, peer.publicKey)) return;
714
+ if (!sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) return;
717
715
  this.unannounce(req.target, peer.publicKey);
718
716
  req.reply(null, {
719
717
  token: false,
@@ -721,8 +719,8 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
721
719
  });
722
720
  }
723
721
  _onrefresh(token, req) {
724
- sodium$6.crypto_generichash(TMP, token);
725
- const activeRefresh = b4a$16.toString(TMP, "hex");
722
+ sodium.crypto_generichash(TMP, token);
723
+ const activeRefresh = b4a.toString(TMP, "hex");
726
724
  const r = this.refreshes.get(activeRefresh);
727
725
  if (!r) return;
728
726
  const { announceSelf, k, record } = r;
@@ -737,7 +735,7 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
737
735
  this.records.remove(k, publicKey);
738
736
  } else this.records.add(k, publicKey, record);
739
737
  this.refreshes.delete(activeRefresh);
740
- this.refreshes.set(b4a$16.toString(token, "hex"), r);
738
+ this.refreshes.set(b4a.toString(token, "hex"), r);
741
739
  req.reply(null, {
742
740
  token: false,
743
741
  closerNodes: false
@@ -747,18 +745,18 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
747
745
  if (!req.target || !req.token || !this.dht.id) return;
748
746
  const ann = decode(m.announce, req.value);
749
747
  if (ann === null) return;
750
- const { peer, refresh, signature, bump } = ann;
748
+ const { peer, refresh, signature, bump, lookup } = ann;
751
749
  if (!peer) {
752
750
  if (!refresh) return;
753
751
  this._onrefresh(refresh, req);
754
752
  return;
755
753
  }
756
754
  const signable = annSignable(req.target, req.token, this.dht.id, ann, NS.ANNOUNCE);
757
- if (!signature || !sodium$6.crypto_sign_verify_detached(signature, signable, peer.publicKey)) return;
755
+ if (!signature || !sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) return;
758
756
  if (peer.relayAddresses.length > 3) peer.relayAddresses = peer.relayAddresses.slice(0, 3);
759
- sodium$6.crypto_generichash(TMP, peer.publicKey);
760
- const k = b4a$16.toString(req.target, "hex");
761
- const announceSelf = b4a$16.equals(TMP, req.target);
757
+ sodium.crypto_generichash(TMP, peer.publicKey);
758
+ const k = b4a.toString(req.target, "hex");
759
+ const announceSelf = b4a.equals(TMP, req.target);
762
760
  const record = encodeUnslab(m.peer, peer);
763
761
  if (announceSelf) {
764
762
  this.dht._router.set(k, {
@@ -772,12 +770,12 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
772
770
  if (bump > (this.bumps.get(k) || 0) && bump <= Date.now() + MAX_BUMP_DRIFT) this.bumps.set(k, bump);
773
771
  this.records.add(k, peer.publicKey, record);
774
772
  }
775
- if (refresh) this.refreshes.set(b4a$16.toString(refresh, "hex"), {
773
+ if (refresh) this.refreshes.set(b4a.toString(refresh, "hex"), {
776
774
  k,
777
775
  record,
778
776
  announceSelf
779
777
  });
780
- req.reply(null, {
778
+ req.reply(lookup ? this._lookupReply(k) : null, {
781
779
  token: false,
782
780
  closerNodes: false
783
781
  });
@@ -786,17 +784,17 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
786
784
  if (!req.target || !req.value) return;
787
785
  let seq = 0;
788
786
  try {
789
- seq = c$4.decode(c$4.uint, req.value);
787
+ seq = c.decode(c.uint, req.value);
790
788
  } catch {
791
789
  return;
792
790
  }
793
- const k = b4a$16.toString(req.target, "hex");
791
+ const k = b4a.toString(req.target, "hex");
794
792
  const value = this.mutables.get(k);
795
793
  if (!value) {
796
794
  req.reply(null);
797
795
  return;
798
796
  }
799
- const localSeq = c$4.decode(c$4.uint, value);
797
+ const localSeq = c.decode(c.uint, value);
800
798
  req.reply(localSeq < seq ? null : value);
801
799
  }
802
800
  onmutableput(req) {
@@ -804,15 +802,15 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
804
802
  const p = decode(m.mutablePutRequest, req.value);
805
803
  if (!p) return;
806
804
  const { publicKey, seq, value, signature } = p;
807
- const hash = b4a$16.allocUnsafe(32);
808
- sodium$6.crypto_generichash(hash, publicKey);
809
- if (!b4a$16.equals(hash, req.target)) return;
805
+ const hash = b4a.allocUnsafe(32);
806
+ sodium.crypto_generichash(hash, publicKey);
807
+ if (!b4a.equals(hash, req.target)) return;
810
808
  if (!value || !verifyMutable(signature, seq, value, publicKey)) return;
811
- const k = b4a$16.toString(hash, "hex");
809
+ const k = b4a.toString(hash, "hex");
812
810
  const local = this.mutables.get(k);
813
811
  if (local) {
814
- const existing = c$4.decode(m.mutableGetResponse, local);
815
- if (existing.value && existing.seq === seq && b4a$16.compare(value, existing.value) !== 0) {
812
+ const existing = c.decode(m.mutableGetResponse, local);
813
+ if (existing.value && existing.seq === seq && b4a.compare(value, existing.value) !== 0) {
816
814
  req.error(ERROR.SEQ_REUSED);
817
815
  return;
818
816
  }
@@ -830,17 +828,17 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
830
828
  }
831
829
  onimmutableget(req) {
832
830
  if (!req.target) return;
833
- const k = b4a$16.toString(req.target, "hex");
831
+ const k = b4a.toString(req.target, "hex");
834
832
  const value = this.immutables.get(k);
835
833
  req.reply(value || null);
836
834
  }
837
835
  onimmutableput(req) {
838
836
  if (!req.target || !req.token || !req.value) return;
839
- const hash = b4a$16.alloc(32);
840
- sodium$6.crypto_generichash(hash, req.value);
841
- if (!b4a$16.equals(hash, req.target)) return;
842
- const k = b4a$16.toString(hash, "hex");
843
- this.immutables.set(k, unslab$1(req.value));
837
+ const hash = b4a.alloc(32);
838
+ sodium.crypto_generichash(hash, req.value);
839
+ if (!b4a.equals(hash, req.target)) return;
840
+ const k = b4a.toString(hash, "hex");
841
+ this.immutables.set(k, unslab(req.value));
844
842
  req.reply(null);
845
843
  }
846
844
  onplugin(req) {
@@ -858,10 +856,10 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
858
856
  this.immutables.destroy();
859
857
  }
860
858
  static signMutable(seq, value, keyPair) {
861
- const signable = b4a$16.allocUnsafe(64);
859
+ const signable = b4a.allocUnsafe(64);
862
860
  const hash = signable.subarray(32);
863
861
  signable.set(NS.MUTABLE_PUT, 0);
864
- sodium$6.crypto_generichash(hash, c$4.encode(m.mutableSignable, {
862
+ sodium.crypto_generichash(hash, c.encode(m.mutableSignable, {
865
863
  seq,
866
864
  value
867
865
  }));
@@ -878,24 +876,24 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
878
876
  }
879
877
  };
880
878
  function verifyMutable(signature, seq, value, publicKey) {
881
- const signable = b4a$16.allocUnsafe(64);
879
+ const signable = b4a.allocUnsafe(64);
882
880
  const hash = signable.subarray(32);
883
881
  signable.set(NS.MUTABLE_PUT, 0);
884
- sodium$6.crypto_generichash(hash, c$4.encode(m.mutableSignable, {
882
+ sodium.crypto_generichash(hash, c.encode(m.mutableSignable, {
885
883
  seq,
886
884
  value
887
885
  }));
888
- return sodium$6.crypto_sign_verify_detached(signature, signable, publicKey);
886
+ return sodium.crypto_sign_verify_detached(signature, signable, publicKey);
889
887
  }
890
888
  function annSignable(target, token, id, ann, ns) {
891
- const signable = b4a$16.allocUnsafe(64);
889
+ const signable = b4a.allocUnsafe(64);
892
890
  const hash = signable.subarray(32);
893
891
  signable.set(ns, 0);
894
- sodium$6.crypto_generichash_batch(hash, [
892
+ sodium.crypto_generichash_batch(hash, [
895
893
  target,
896
894
  id,
897
895
  token,
898
- c$4.encode(m.peer, ann.peer),
896
+ c.encode(m.peer, ann.peer),
899
897
  ann.refresh || EMPTY
900
898
  ]);
901
899
  return signable;
@@ -903,20 +901,19 @@ var require_persistent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
903
901
  function sign(signable, keyPair) {
904
902
  if (keyPair.sign) return keyPair.sign(signable);
905
903
  const secretKey = keyPair.secretKey ? keyPair.secretKey : keyPair;
906
- const signature = b4a$16.allocUnsafe(64);
907
- sodium$6.crypto_sign_detached(signature, signable, secretKey);
904
+ const signature = b4a.allocUnsafe(64);
905
+ sodium.crypto_sign_detached(signature, signable, secretKey);
908
906
  return signature;
909
907
  }
910
908
  function decode(enc, val) {
911
909
  try {
912
- return val && c$4.decode(enc, val);
910
+ return val && c.decode(enc, val);
913
911
  } catch (err) {
914
912
  return null;
915
913
  }
916
914
  }
917
915
  }));
918
- //#endregion
919
- //#region ../../node_modules/hyperdht/lib/errors.js
916
+ // ../../node_modules/hyperdht/lib/errors.js
920
917
  var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
921
918
  module.exports = class DHTError extends Error {
922
919
  constructor(msg, code, fn = DHTError) {
@@ -998,13 +995,12 @@ var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
998
995
  }
999
996
  };
1000
997
  }));
1001
- //#endregion
1002
- //#region ../../node_modules/hyperdht/lib/router.js
998
+ // ../../node_modules/hyperdht/lib/router.js
1003
999
  var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1004
- var c$3 = __require("compact-encoding");
1005
- var Cache$1 = __require("xache");
1006
- var safetyCatch$5 = __require("safety-catch");
1007
- var b4a$15 = __require("b4a");
1000
+ var c = __require("compact-encoding");
1001
+ var Cache = __require("xache");
1002
+ var safetyCatch = __require("safety-catch");
1003
+ var b4a = __require("b4a");
1008
1004
  var { handshake, holepunch } = require_messages();
1009
1005
  var { COMMANDS } = require_constants();
1010
1006
  var { BAD_HANDSHAKE_REPLY, BAD_HOLEPUNCH_REPLY } = require_errors();
@@ -1016,7 +1012,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1016
1012
  module.exports = class Router {
1017
1013
  constructor(dht, opts) {
1018
1014
  this.dht = dht;
1019
- this.forwards = new Cache$1(opts.forwards);
1015
+ this.forwards = new Cache(opts.forwards);
1020
1016
  }
1021
1017
  set(target, state) {
1022
1018
  if (state.onpeerhandshake) this.forwards.retain(toString(target), state);
@@ -1033,7 +1029,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1033
1029
  }
1034
1030
  async peerHandshake(target, { noise, peerAddress, relayAddress, socket, session }, to) {
1035
1031
  const dht = this.dht;
1036
- const requestValue = c$3.encode(handshake, {
1032
+ const requestValue = c.encode(handshake, {
1037
1033
  mode: FROM_CLIENT,
1038
1034
  noise,
1039
1035
  peerAddress,
@@ -1071,7 +1067,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1071
1067
  peerAddress
1072
1068
  }, req);
1073
1069
  } catch (e) {
1074
- safetyCatch$5(e);
1070
+ safetyCatch(e);
1075
1071
  return;
1076
1072
  }
1077
1073
  if (!reply || !reply.noise) return;
@@ -1082,14 +1078,14 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1082
1078
  };
1083
1079
  switch (mode) {
1084
1080
  case FROM_CLIENT:
1085
- req.reply(c$3.encode(handshake, {
1081
+ req.reply(c.encode(handshake, {
1086
1082
  mode: REPLY,
1087
1083
  noise: reply.noise,
1088
1084
  peerAddress: null
1089
1085
  }), opts);
1090
1086
  return;
1091
1087
  case FROM_RELAY:
1092
- req.relay(c$3.encode(handshake, {
1088
+ req.relay(c.encode(handshake, {
1093
1089
  mode: FROM_SERVER,
1094
1090
  noise: reply.noise,
1095
1091
  peerAddress
@@ -1097,7 +1093,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1097
1093
  return;
1098
1094
  case FROM_SECOND_RELAY:
1099
1095
  if (!relayAddress) return;
1100
- req.relay(c$3.encode(handshake, {
1096
+ req.relay(c.encode(handshake, {
1101
1097
  mode: FROM_SERVER,
1102
1098
  noise: reply.noise,
1103
1099
  peerAddress
@@ -1114,7 +1110,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1114
1110
  });
1115
1111
  return;
1116
1112
  }
1117
- req.relay(c$3.encode(handshake, {
1113
+ req.relay(c.encode(handshake, {
1118
1114
  mode: FROM_RELAY,
1119
1115
  noise,
1120
1116
  peerAddress: req.from,
@@ -1123,7 +1119,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1123
1119
  return;
1124
1120
  case FROM_RELAY:
1125
1121
  if (!relay || !noise) return;
1126
- req.relay(c$3.encode(handshake, {
1122
+ req.relay(c.encode(handshake, {
1127
1123
  mode: FROM_SECOND_RELAY,
1128
1124
  noise,
1129
1125
  peerAddress,
@@ -1132,7 +1128,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1132
1128
  return;
1133
1129
  case FROM_SERVER:
1134
1130
  if (!peerAddress || !noise) return;
1135
- req.reply(c$3.encode(handshake, {
1131
+ req.reply(c.encode(handshake, {
1136
1132
  mode: REPLY,
1137
1133
  noise,
1138
1134
  peerAddress: req.from,
@@ -1147,7 +1143,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1147
1143
  }
1148
1144
  async peerHolepunch(target, { id, payload, peerAddress, socket, session }, to) {
1149
1145
  const dht = this.dht;
1150
- const requestValue = c$3.encode(holepunch, {
1146
+ const requestValue = c.encode(holepunch, {
1151
1147
  mode: FROM_CLIENT,
1152
1148
  id,
1153
1149
  payload,
@@ -1180,7 +1176,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1180
1176
  switch (mode) {
1181
1177
  case FROM_CLIENT:
1182
1178
  if (!peerAddress && !relay) return;
1183
- req.relay(c$3.encode(holepunch, {
1179
+ req.relay(c.encode(holepunch, {
1184
1180
  mode: FROM_RELAY,
1185
1181
  id,
1186
1182
  payload,
@@ -1197,7 +1193,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1197
1193
  peerAddress
1198
1194
  }, req);
1199
1195
  } catch (e) {
1200
- safetyCatch$5(e);
1196
+ safetyCatch(e);
1201
1197
  return;
1202
1198
  }
1203
1199
  if (!reply) return;
@@ -1206,7 +1202,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1206
1202
  closerNodes: false,
1207
1203
  token: false
1208
1204
  };
1209
- req.relay(c$3.encode(holepunch, {
1205
+ req.relay(c.encode(holepunch, {
1210
1206
  mode: FROM_SERVER,
1211
1207
  id: 0,
1212
1208
  payload: reply.payload,
@@ -1215,7 +1211,7 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1215
1211
  return;
1216
1212
  }
1217
1213
  case FROM_SERVER:
1218
- req.reply(c$3.encode(holepunch, {
1214
+ req.reply(c.encode(holepunch, {
1219
1215
  mode: REPLY,
1220
1216
  id,
1221
1217
  payload,
@@ -1231,20 +1227,19 @@ var require_router = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1231
1227
  };
1232
1228
  function decode(enc, val) {
1233
1229
  try {
1234
- return c$3.decode(enc, val);
1230
+ return c.decode(enc, val);
1235
1231
  } catch {
1236
1232
  return null;
1237
1233
  }
1238
1234
  }
1239
1235
  function toString(t) {
1240
- return typeof t === "string" ? t : b4a$15.toString(t, "hex");
1236
+ return typeof t === "string" ? t : b4a.toString(t, "hex");
1241
1237
  }
1242
1238
  }));
1243
- //#endregion
1244
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/cipher.js
1239
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/cipher.js
1245
1240
  var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1246
- var sodium$5 = __require("sodium-universal");
1247
- var b4a$14 = __require("b4a");
1241
+ var sodium = __require("sodium-universal");
1242
+ var b4a = __require("b4a");
1248
1243
  module.exports = class CipherState {
1249
1244
  constructor(key) {
1250
1245
  this.key = key || null;
@@ -1260,7 +1255,7 @@ var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1260
1255
  }
1261
1256
  encrypt(plaintext, ad) {
1262
1257
  if (!this.hasKey) return plaintext;
1263
- if (!ad) ad = b4a$14.alloc(0);
1258
+ if (!ad) ad = b4a.alloc(0);
1264
1259
  const ciphertext = encryptWithAD(this.key, this.nonce, ad, plaintext);
1265
1260
  if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`);
1266
1261
  this.nonce++;
@@ -1268,7 +1263,7 @@ var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1268
1263
  }
1269
1264
  decrypt(ciphertext, ad) {
1270
1265
  if (!this.hasKey) return ciphertext;
1271
- if (!ad) ad = b4a$14.alloc(0);
1266
+ if (!ad) ad = b4a.alloc(0);
1272
1267
  if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`);
1273
1268
  const plaintext = decryptWithAD(this.key, this.nonce, ad, ciphertext);
1274
1269
  this.nonce++;
@@ -1278,7 +1273,7 @@ var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1278
1273
  return this.key !== null;
1279
1274
  }
1280
1275
  _clear() {
1281
- sodium$5.sodium_memzero(this.key);
1276
+ sodium.sodium_memzero(this.key);
1282
1277
  this.key = null;
1283
1278
  this.nonce = null;
1284
1279
  }
@@ -1293,30 +1288,30 @@ var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1293
1288
  }
1294
1289
  };
1295
1290
  function encryptWithAD(key, counter, additionalData, plaintext) {
1296
- if (!b4a$14.isBuffer(additionalData)) additionalData = b4a$14.from(additionalData, "hex");
1297
- if (!b4a$14.isBuffer(plaintext)) plaintext = b4a$14.from(plaintext, "hex");
1298
- const nonce = b4a$14.alloc(sodium$5.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
1291
+ if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, "hex");
1292
+ if (!b4a.isBuffer(plaintext)) plaintext = b4a.from(plaintext, "hex");
1293
+ const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
1299
1294
  new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength).setUint32(4, counter, true);
1300
- const ciphertext = b4a$14.alloc(plaintext.byteLength + sodium$5.crypto_aead_chacha20poly1305_ietf_ABYTES);
1301
- sodium$5.crypto_aead_chacha20poly1305_ietf_encrypt(ciphertext, plaintext, additionalData, null, nonce, key);
1295
+ const ciphertext = b4a.alloc(plaintext.byteLength + sodium.crypto_aead_chacha20poly1305_ietf_ABYTES);
1296
+ sodium.crypto_aead_chacha20poly1305_ietf_encrypt(ciphertext, plaintext, additionalData, null, nonce, key);
1302
1297
  return ciphertext;
1303
1298
  }
1304
1299
  function decryptWithAD(key, counter, additionalData, ciphertext) {
1305
- if (!b4a$14.isBuffer(additionalData)) additionalData = b4a$14.from(additionalData, "hex");
1306
- if (!b4a$14.isBuffer(ciphertext)) ciphertext = b4a$14.from(ciphertext, "hex");
1307
- const nonce = b4a$14.alloc(sodium$5.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
1300
+ if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, "hex");
1301
+ if (!b4a.isBuffer(ciphertext)) ciphertext = b4a.from(ciphertext, "hex");
1302
+ if (ciphertext.byteLength < sodium.crypto_aead_chacha20poly1305_ietf_ABYTES) throw new Error(`ciphertext length of ${ciphertext.byteLength} is shorter than the MAC`);
1303
+ const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
1308
1304
  new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength).setUint32(4, counter, true);
1309
- const plaintext = b4a$14.alloc(ciphertext.byteLength - sodium$5.crypto_aead_chacha20poly1305_ietf_ABYTES);
1310
- sodium$5.crypto_aead_chacha20poly1305_ietf_decrypt(plaintext, null, ciphertext, additionalData, nonce, key);
1305
+ const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_aead_chacha20poly1305_ietf_ABYTES);
1306
+ sodium.crypto_aead_chacha20poly1305_ietf_decrypt(plaintext, null, ciphertext, additionalData, nonce, key);
1311
1307
  return plaintext;
1312
1308
  }
1313
1309
  }));
1314
- //#endregion
1315
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/dh.js
1310
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/dh.js
1316
1311
  var require_dh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1317
1312
  var { crypto_kx_SEEDBYTES, crypto_kx_keypair, crypto_kx_seed_keypair, crypto_scalarmult_BYTES, crypto_scalarmult_SCALARBYTES, crypto_scalarmult, crypto_scalarmult_base } = __require("sodium-universal");
1318
- var assert$2 = __require("nanoassert");
1319
- var b4a$13 = __require("b4a");
1313
+ var assert = __require("nanoassert");
1314
+ var b4a = __require("b4a");
1320
1315
  var DHLEN = crypto_scalarmult_BYTES;
1321
1316
  var PKLEN = crypto_scalarmult_BYTES;
1322
1317
  var SKLEN = crypto_scalarmult_SCALARBYTES;
@@ -1332,36 +1327,35 @@ var require_dh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1332
1327
  };
1333
1328
  function generateKeyPair(privKey) {
1334
1329
  const keyPair = {};
1335
- keyPair.secretKey = privKey || b4a$13.alloc(SKLEN);
1336
- keyPair.publicKey = b4a$13.alloc(PKLEN);
1330
+ keyPair.secretKey = privKey || b4a.alloc(SKLEN);
1331
+ keyPair.publicKey = b4a.alloc(PKLEN);
1337
1332
  if (privKey) crypto_scalarmult_base(keyPair.publicKey, keyPair.secretKey);
1338
1333
  else crypto_kx_keypair(keyPair.publicKey, keyPair.secretKey);
1339
1334
  return keyPair;
1340
1335
  }
1341
1336
  function generateSeedKeyPair(seed) {
1342
- assert$2(seed.byteLength === SKLEN);
1337
+ assert(seed.byteLength === SKLEN);
1343
1338
  const keyPair = {};
1344
- keyPair.secretKey = b4a$13.alloc(SKLEN);
1345
- keyPair.publicKey = b4a$13.alloc(PKLEN);
1339
+ keyPair.secretKey = b4a.alloc(SKLEN);
1340
+ keyPair.publicKey = b4a.alloc(PKLEN);
1346
1341
  crypto_kx_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed);
1347
1342
  return keyPair;
1348
1343
  }
1349
1344
  function dh(publicKey, { secretKey }) {
1350
- assert$2(secretKey.byteLength === SKLEN);
1351
- assert$2(publicKey.byteLength === PKLEN);
1352
- const output = b4a$13.alloc(DHLEN);
1345
+ assert(secretKey.byteLength === SKLEN);
1346
+ assert(publicKey.byteLength === PKLEN);
1347
+ const output = b4a.alloc(DHLEN);
1353
1348
  crypto_scalarmult(output, secretKey, publicKey);
1354
1349
  return output;
1355
1350
  }
1356
1351
  }));
1357
- //#endregion
1358
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/hmac.js
1352
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/hmac.js
1359
1353
  var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1360
- var b4a$12 = __require("b4a");
1354
+ var b4a = __require("b4a");
1361
1355
  var { sodium_memzero, crypto_generichash, crypto_generichash_batch } = __require("sodium-universal");
1362
1356
  var HASHLEN = 64;
1363
1357
  var BLOCKLEN = 128;
1364
- var scratch = b4a$12.alloc(384);
1358
+ var scratch = b4a.alloc(384);
1365
1359
  var HMACKey = scratch.subarray(0, 128);
1366
1360
  var OuterKeyPad = scratch.subarray(128, 256);
1367
1361
  var InnerKeyPad = scratch.subarray(256, 384);
@@ -1386,11 +1380,10 @@ var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1386
1380
  module.exports.BYTES = HASHLEN;
1387
1381
  module.exports.KEYBYTES = BLOCKLEN;
1388
1382
  }));
1389
- //#endregion
1390
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/hkdf.js
1383
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/hkdf.js
1391
1384
  var require_hkdf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1392
1385
  var hmacBlake2b = require_hmac();
1393
- var b4a$11 = __require("b4a");
1386
+ var b4a = __require("b4a");
1394
1387
  var HASHLEN = 64;
1395
1388
  module.exports = {
1396
1389
  hkdf,
@@ -1400,15 +1393,15 @@ var require_hkdf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1400
1393
  return hkdfExpand(hkdfExtract(salt, inputKeyMaterial), info, length);
1401
1394
  }
1402
1395
  function hkdfExtract(salt, inputKeyMaterial) {
1403
- return hmacDigest(b4a$11.alloc(HASHLEN), salt, inputKeyMaterial);
1396
+ return hmacDigest(b4a.alloc(HASHLEN), salt, inputKeyMaterial);
1404
1397
  }
1405
1398
  function hkdfExpand(key, info, length) {
1406
- const buffer = b4a$11.allocUnsafeSlow(length);
1407
- const infoBuf = b4a$11.from(info);
1399
+ const buffer = b4a.allocUnsafeSlow(length);
1400
+ const infoBuf = b4a.from(info);
1408
1401
  let prev = infoBuf;
1409
1402
  const result = [];
1410
1403
  for (let i = 0; i < length; i += HASHLEN) {
1411
- const pos = b4a$11.from([i / HASHLEN + 1]);
1404
+ const pos = b4a.from([i / HASHLEN + 1]);
1412
1405
  const out = buffer.subarray(i, i + HASHLEN);
1413
1406
  result.push(out);
1414
1407
  prev = hmacDigest(out, key, [
@@ -1424,12 +1417,11 @@ var require_hkdf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1424
1417
  return out;
1425
1418
  }
1426
1419
  }));
1427
- //#endregion
1428
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/symmetric-state.js
1420
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/symmetric-state.js
1429
1421
  var require_symmetric_state = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1430
- var sodium$4 = __require("sodium-universal");
1431
- var assert$1 = __require("nanoassert");
1432
- var b4a$10 = __require("b4a");
1422
+ var sodium = __require("sodium-universal");
1423
+ var assert = __require("nanoassert");
1424
+ var b4a = __require("b4a");
1433
1425
  var CipherState = require_cipher();
1434
1426
  var curve = require_dh();
1435
1427
  var { HASHLEN, hkdf } = require_hkdf();
@@ -1437,7 +1429,7 @@ var require_symmetric_state = /* @__PURE__ */ __commonJSMin(((exports, module) =
1437
1429
  constructor(opts = {}) {
1438
1430
  super();
1439
1431
  this.curve = opts.curve || curve;
1440
- this.digest = b4a$10.alloc(HASHLEN);
1432
+ this.digest = b4a.alloc(HASHLEN);
1441
1433
  this.chainingKey = null;
1442
1434
  this.offset = 0;
1443
1435
  this.DH_ALG = this.curve.ALG;
@@ -1473,18 +1465,18 @@ var require_symmetric_state = /* @__PURE__ */ __commonJSMin(((exports, module) =
1473
1465
  return plaintext;
1474
1466
  }
1475
1467
  getHandshakeHash(out) {
1476
- if (!out) return this.getHandshakeHash(b4a$10.alloc(HASHLEN));
1477
- assert$1(out.byteLength === HASHLEN, `output must be ${HASHLEN} bytes`);
1468
+ if (!out) return this.getHandshakeHash(b4a.alloc(HASHLEN));
1469
+ assert(out.byteLength === HASHLEN, `output must be ${HASHLEN} bytes`);
1478
1470
  out.set(this.digest);
1479
1471
  return out;
1480
1472
  }
1481
1473
  split() {
1482
- return hkdf(this.chainingKey, b4a$10.alloc(0)).map((k) => k.subarray(0, 32));
1474
+ return hkdf(this.chainingKey, b4a.alloc(0)).map((k) => k.subarray(0, 32));
1483
1475
  }
1484
1476
  _clear() {
1485
1477
  super._clear();
1486
- sodium$4.sodium_memzero(this.digest);
1487
- sodium$4.sodium_memzero(this.chainingKey);
1478
+ sodium.sodium_memzero(this.digest);
1479
+ sodium.sodium_memzero(this.chainingKey);
1488
1480
  this.digest = null;
1489
1481
  this.chainingKey = null;
1490
1482
  this.offset = null;
@@ -1495,15 +1487,14 @@ var require_symmetric_state = /* @__PURE__ */ __commonJSMin(((exports, module) =
1495
1487
  }
1496
1488
  };
1497
1489
  function accumulateDigest(digest, input) {
1498
- const toHash = b4a$10.concat([digest, input]);
1499
- sodium$4.crypto_generichash(digest, toHash);
1490
+ const toHash = b4a.concat([digest, input]);
1491
+ sodium.crypto_generichash(digest, toHash);
1500
1492
  }
1501
1493
  }));
1502
- //#endregion
1503
- //#region ../../node_modules/hyperdht/node_modules/noise-handshake/noise.js
1494
+ // ../../node_modules/hyperdht/node_modules/noise-handshake/noise.js
1504
1495
  var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1505
1496
  var assert = __require("nanoassert");
1506
- var b4a$9 = __require("b4a");
1497
+ var b4a = __require("b4a");
1507
1498
  var SymmetricState = require_symmetric_state();
1508
1499
  var { HASHLEN } = require_hkdf();
1509
1500
  var PRESHARE_IS = Symbol("initiator static key preshared");
@@ -1569,7 +1560,7 @@ var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1569
1560
  this.buffers.push(b);
1570
1561
  }
1571
1562
  end() {
1572
- const all = b4a$9.alloc(this.size);
1563
+ const all = b4a.alloc(this.size);
1573
1564
  let offset = 0;
1574
1565
  for (const b of this.buffers) {
1575
1566
  all.set(b, offset);
@@ -1605,7 +1596,7 @@ var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1605
1596
  this.pattern = pattern;
1606
1597
  this.handshake = HANDSHAKES[this.pattern].slice();
1607
1598
  this.isPskHandshake = !!this.psk && hasPskToken(this.handshake);
1608
- this.protocol = b4a$9.from([
1599
+ this.protocol = b4a.from([
1609
1600
  "Noise",
1610
1601
  this.pattern,
1611
1602
  this.DH_ALG,
@@ -1621,7 +1612,7 @@ var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1621
1612
  initialise(prologue, remoteStatic) {
1622
1613
  if (this.protocol.byteLength <= HASHLEN) this.digest.set(this.protocol);
1623
1614
  else this.mixHash(this.protocol);
1624
- this.chainingKey = b4a$9.from(this.digest);
1615
+ this.chainingKey = b4a.from(this.digest);
1625
1616
  this.mixHash(prologue);
1626
1617
  while (!Array.isArray(this.handshake[0])) {
1627
1618
  const message = this.handshake.shift();
@@ -1673,7 +1664,7 @@ var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1673
1664
  if (!this.handshake.length) this.final();
1674
1665
  return payload;
1675
1666
  }
1676
- send(payload = b4a$9.alloc(0)) {
1667
+ send(payload = b4a.alloc(0)) {
1677
1668
  const w = new Writer();
1678
1669
  for (const pattern of this.handshake.shift()) switch (pattern) {
1679
1670
  case TOK_PSK:
@@ -1741,15 +1732,14 @@ var require_noise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1741
1732
  });
1742
1733
  }
1743
1734
  }));
1744
- //#endregion
1745
- //#region ../../node_modules/hyperdht/lib/noise-wrap.js
1735
+ // ../../node_modules/hyperdht/lib/noise-wrap.js
1746
1736
  var require_noise_wrap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1747
- var NoiseSecretStream$2 = __require("@hyperswarm/secret-stream");
1737
+ var NoiseSecretStream = __require("@hyperswarm/secret-stream");
1748
1738
  var NoiseHandshake = require_noise();
1749
1739
  var curve = __require("noise-curve-ed");
1750
- var c$2 = __require("compact-encoding");
1751
- var b4a$8 = __require("b4a");
1752
- var sodium$3 = __require("sodium-universal");
1740
+ var c = __require("compact-encoding");
1741
+ var b4a = __require("b4a");
1742
+ var sodium = __require("sodium-universal");
1753
1743
  var m = require_messages();
1754
1744
  var { NS } = require_constants();
1755
1745
  var { HANDSHAKE_UNFINISHED } = require_errors();
@@ -1763,34 +1753,33 @@ var require_noise_wrap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1763
1753
  this.handshake.initialise(NOISE_PROLOUGE, remotePublicKey);
1764
1754
  }
1765
1755
  send(payload) {
1766
- const buf = c$2.encode(m.noisePayload, payload);
1756
+ const buf = c.encode(m.noisePayload, payload);
1767
1757
  return this.handshake.send(buf);
1768
1758
  }
1769
1759
  recv(buf) {
1770
- const payload = c$2.decode(m.noisePayload, this.handshake.recv(buf));
1771
- this.remotePublicKey = b4a$8.toBuffer(this.handshake.rs);
1760
+ const payload = c.decode(m.noisePayload, this.handshake.recv(buf));
1761
+ this.remotePublicKey = b4a.toBuffer(this.handshake.rs);
1772
1762
  return payload;
1773
1763
  }
1774
1764
  final() {
1775
1765
  if (!this.handshake.complete) throw HANDSHAKE_UNFINISHED();
1776
- const holepunchSecret = b4a$8.allocUnsafe(32);
1777
- sodium$3.crypto_generichash(holepunchSecret, NS.PEER_HOLEPUNCH, this.handshake.hash);
1766
+ const holepunchSecret = b4a.allocUnsafe(32);
1767
+ sodium.crypto_generichash(holepunchSecret, NS.PEER_HOLEPUNCH, this.handshake.hash);
1778
1768
  return {
1779
1769
  isInitiator: this.isInitiator,
1780
1770
  publicKey: this.keyPair.publicKey,
1781
1771
  streamId: this.streamId,
1782
1772
  remotePublicKey: this.remotePublicKey,
1783
- remoteId: NoiseSecretStream$2.id(this.handshake.hash, !this.isInitiator),
1773
+ remoteId: NoiseSecretStream.id(this.handshake.hash, !this.isInitiator),
1784
1774
  holepunchSecret,
1785
- hash: b4a$8.toBuffer(this.handshake.hash),
1786
- rx: b4a$8.toBuffer(this.handshake.rx),
1787
- tx: b4a$8.toBuffer(this.handshake.tx)
1775
+ hash: b4a.toBuffer(this.handshake.hash),
1776
+ rx: b4a.toBuffer(this.handshake.rx),
1777
+ tx: b4a.toBuffer(this.handshake.tx)
1788
1778
  };
1789
1779
  }
1790
1780
  };
1791
1781
  }));
1792
- //#endregion
1793
- //#region ../../node_modules/hyperdht/lib/sleeper.js
1782
+ // ../../node_modules/hyperdht/lib/sleeper.js
1794
1783
  var require_sleeper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1795
1784
  module.exports = class Sleeper {
1796
1785
  constructor() {
@@ -1824,11 +1813,10 @@ var require_sleeper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1824
1813
  }
1825
1814
  };
1826
1815
  }));
1827
- //#endregion
1828
- //#region ../../node_modules/hyperdht/lib/announcer.js
1816
+ // ../../node_modules/hyperdht/lib/announcer.js
1829
1817
  var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1830
- var safetyCatch$4 = __require("safety-catch");
1831
- var c$1 = __require("compact-encoding");
1818
+ var safetyCatch = __require("safety-catch");
1819
+ var c = __require("compact-encoding");
1832
1820
  var Signal = __require("signal-promise");
1833
1821
  var { encodeUnslab } = require_encode();
1834
1822
  var Sleeper = require_sleeper();
@@ -1836,6 +1824,8 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1836
1824
  var Persistent = require_persistent();
1837
1825
  var { COMMANDS } = require_constants();
1838
1826
  var MIN_ACTIVE = 3;
1827
+ var MAX_ANNOUNCE_RELAYS = 3;
1828
+ var RTT_CANDIDATE_WINDOW = 8;
1839
1829
  module.exports = class Announcer {
1840
1830
  constructor(dht, keyPair, target, opts = {}) {
1841
1831
  this.dht = dht;
@@ -1860,6 +1850,7 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1860
1850
  this._updating = null;
1861
1851
  this._activeQuery = null;
1862
1852
  this._unannouncing = null;
1853
+ this._stopping = null;
1863
1854
  this._serverRelays = [
1864
1855
  /* @__PURE__ */ new Map(),
1865
1856
  /* @__PURE__ */ new Map(),
@@ -1880,9 +1871,10 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1880
1871
  this._sleeper.resume();
1881
1872
  if (this._updating) await this._updating;
1882
1873
  log("Suspending announcer (post update)");
1883
- if (this.suspended === false || this.stopped) return;
1874
+ if (this.stopped) return this._stopping;
1875
+ if (this.suspended === false) return;
1884
1876
  log("Suspending announcer (pre unannounce)");
1885
- await this._unannounceCurrent();
1877
+ await this._unannounceCurrent(true);
1886
1878
  log("Suspending announcer (post unannounce)");
1887
1879
  }
1888
1880
  resume() {
@@ -1903,17 +1895,23 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1903
1895
  if (this.stopped) return;
1904
1896
  this._active = this._background();
1905
1897
  }
1906
- async stop() {
1898
+ stop() {
1899
+ if (this._stopping) return this._stopping;
1900
+ this._stopping = this._stop();
1901
+ return this._stopping;
1902
+ }
1903
+ async _stop() {
1907
1904
  this.stopped = true;
1908
1905
  this.online.notify();
1906
+ if (this._activeQuery) this._activeQuery.destroy();
1909
1907
  this._sleeper.resume();
1910
1908
  this._resumed.notify();
1911
1909
  await this._active;
1912
1910
  await this._unannounceCurrent();
1913
1911
  }
1914
- async _unannounceCurrent() {
1912
+ async _unannounceCurrent(force) {
1915
1913
  while (this._unannouncing !== null) await this._unannouncing;
1916
- const un = this._unannouncing = this._unannounceAll(this._serverRelays[2].values());
1914
+ const un = this._unannouncing = this._unannounceAll(this._serverRelays[2].values(), force);
1917
1915
  await this._unannouncing;
1918
1916
  if (un === this._unannouncing) this._unannouncing = null;
1919
1917
  }
@@ -1926,12 +1924,13 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1926
1924
  if (await resolved(pings) < Math.min(pings.length, MIN_ACTIVE)) this.refresh();
1927
1925
  if (this.stopped) return;
1928
1926
  if (!this.suspended && !this._refreshing) await this._sleeper.pause(3e3);
1927
+ if (pings.length === 0) this.refresh();
1929
1928
  }
1930
1929
  while (!this.stopped && this.suspended) await this._resumed.wait();
1931
1930
  if (!this.stopped) await this._runUpdate();
1932
1931
  while (!this.dht.online && !this.stopped && !this.suspended) await this.online.wait();
1933
1932
  } catch (err) {
1934
- safetyCatch$4(err);
1933
+ safetyCatch(err);
1935
1934
  }
1936
1935
  }
1937
1936
  async _runUpdate() {
@@ -1941,7 +1940,7 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1941
1940
  }
1942
1941
  async _update() {
1943
1942
  while (this._unannouncing) await this._unannouncing;
1944
- this._cycle();
1943
+ if (this.stopped || this.suspended) return;
1945
1944
  const q = this._activeQuery = this.dht.findPeer(this.target, {
1946
1945
  hash: false,
1947
1946
  nodes: this._closestNodes
@@ -1951,6 +1950,7 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1951
1950
  } catch {}
1952
1951
  this._activeQuery = null;
1953
1952
  if (this.stopped || this.suspended) return;
1953
+ this._cycle();
1954
1954
  const ann = [];
1955
1955
  const replies = pickBest(q.closestReplies);
1956
1956
  const relays = [];
@@ -1969,12 +1969,12 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1969
1969
  for (const [key, value] of this._serverRelays[1]) if (!this._serverRelays[2].has(key)) removed.push(value);
1970
1970
  await this._unannounceAll(removed);
1971
1971
  }
1972
- _unannounceAll(relays) {
1972
+ _unannounceAll(relays, force) {
1973
1973
  const unann = [];
1974
- for (const r of relays) unann.push(this._unannounce(r));
1974
+ for (const r of relays) unann.push(this._unannounce(r, force));
1975
1975
  return Promise.allSettled(unann);
1976
1976
  }
1977
- async _unannounce(to) {
1977
+ async _unannounce(to, force) {
1978
1978
  const unann = {
1979
1979
  peer: {
1980
1980
  publicKey: this.keyPair.publicKey,
@@ -1988,15 +1988,15 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1988
1988
  command: COMMANDS.FIND_PEER,
1989
1989
  target: this.target,
1990
1990
  value: null
1991
- }, to);
1991
+ }, to, { retry: !force });
1992
1992
  if (!token || !from.id || !value) return;
1993
1993
  unann.signature = await this._signUnannounce(this.target, token, from.id, unann, this.keyPair);
1994
1994
  await this.dht.request({
1995
1995
  token,
1996
1996
  command: COMMANDS.UNANNOUNCE,
1997
1997
  target: this.target,
1998
- value: c$1.encode(m.announce, unann)
1999
- }, to);
1998
+ value: c.encode(m.announce, unann)
1999
+ }, to, { retry: !force });
2000
2000
  }
2001
2001
  async _commit(msg, relays, relayAddresses) {
2002
2002
  const ann = {
@@ -2012,7 +2012,7 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2012
2012
  token: msg.token,
2013
2013
  command: COMMANDS.ANNOUNCE,
2014
2014
  target: this.target,
2015
- value: c$1.encode(m.announce, ann)
2015
+ value: c.encode(m.announce, ann)
2016
2016
  }, msg.from)).error !== 0) return;
2017
2017
  if (relayAddresses.length < 3) relayAddresses.push({
2018
2018
  host: msg.from.host,
@@ -2048,30 +2048,34 @@ var require_announcer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2048
2048
  });
2049
2049
  }
2050
2050
  function pickBest(replies) {
2051
- return replies.slice(0, 3);
2051
+ const best = replies.slice(0, RTT_CANDIDATE_WINDOW);
2052
+ best.sort(compareRTT);
2053
+ return best.slice(0, MAX_ANNOUNCE_RELAYS);
2054
+ }
2055
+ function compareRTT(a, b) {
2056
+ return a.rtt - b.rtt;
2052
2057
  }
2053
2058
  function noop() {}
2054
2059
  }));
2055
- //#endregion
2056
- //#region ../../node_modules/hyperdht/lib/crypto.js
2060
+ // ../../node_modules/hyperdht/lib/crypto.js
2057
2061
  var require_crypto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2058
- var sodium$2 = __require("sodium-universal");
2059
- var b4a$7 = __require("b4a");
2062
+ var sodium = __require("sodium-universal");
2063
+ var b4a = __require("b4a");
2060
2064
  function hash(data) {
2061
- const out = b4a$7.allocUnsafe(32);
2062
- sodium$2.crypto_generichash(out, data);
2065
+ const out = b4a.allocUnsafe(32);
2066
+ sodium.crypto_generichash(out, data);
2063
2067
  return out;
2064
2068
  }
2065
2069
  function unslabbedHash(data) {
2066
- const out = b4a$7.allocUnsafeSlow(32);
2067
- sodium$2.crypto_generichash(out, data);
2070
+ const out = b4a.allocUnsafeSlow(32);
2071
+ sodium.crypto_generichash(out, data);
2068
2072
  return out;
2069
2073
  }
2070
2074
  function createKeyPair(seed) {
2071
- const publicKey = b4a$7.alloc(32);
2072
- const secretKey = b4a$7.alloc(64);
2073
- if (seed) sodium$2.crypto_sign_seed_keypair(publicKey, secretKey, seed);
2074
- else sodium$2.crypto_sign_keypair(publicKey, secretKey);
2075
+ const publicKey = b4a.alloc(32);
2076
+ const secretKey = b4a.alloc(64);
2077
+ if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed);
2078
+ else sodium.crypto_sign_keypair(publicKey, secretKey);
2075
2079
  return {
2076
2080
  publicKey,
2077
2081
  secretKey
@@ -2083,17 +2087,16 @@ var require_crypto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2083
2087
  createKeyPair
2084
2088
  };
2085
2089
  }));
2086
- //#endregion
2087
- //#region ../../node_modules/hyperdht/lib/secure-payload.js
2090
+ // ../../node_modules/hyperdht/lib/secure-payload.js
2088
2091
  var require_secure_payload = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2089
- var sodium$1 = __require("sodium-universal");
2090
- var b4a$6 = __require("b4a");
2092
+ var sodium = __require("sodium-universal");
2093
+ var b4a = __require("b4a");
2091
2094
  var { holepunchPayload } = require_messages();
2092
2095
  module.exports = class HolepunchPayload {
2093
2096
  constructor(holepunchSecret) {
2094
2097
  this._sharedSecret = holepunchSecret;
2095
- this._localSecret = b4a$6.allocUnsafe(32);
2096
- sodium$1.randombytes_buf(this._localSecret);
2098
+ this._localSecret = b4a.allocUnsafe(32);
2099
+ sodium.randombytes_buf(this._localSecret);
2097
2100
  }
2098
2101
  decrypt(buffer) {
2099
2102
  const state = {
@@ -2105,7 +2108,7 @@ var require_secure_payload = /* @__PURE__ */ __commonJSMin(((exports, module) =>
2105
2108
  const nonce = buffer.subarray(0, 24);
2106
2109
  const msg = state.buffer.subarray(state.start, state.end);
2107
2110
  const cipher = state.buffer.subarray(state.start);
2108
- if (!sodium$1.crypto_secretbox_open_easy(msg, cipher, nonce, this._sharedSecret)) return null;
2111
+ if (!sodium.crypto_secretbox_open_easy(msg, cipher, nonce, this._sharedSecret)) return null;
2109
2112
  try {
2110
2113
  return holepunchPayload.decode(state);
2111
2114
  } catch {
@@ -2119,24 +2122,23 @@ var require_secure_payload = /* @__PURE__ */ __commonJSMin(((exports, module) =>
2119
2122
  buffer: null
2120
2123
  };
2121
2124
  holepunchPayload.preencode(state, payload);
2122
- state.buffer = b4a$6.allocUnsafe(state.end + 16);
2125
+ state.buffer = b4a.allocUnsafe(state.end + 16);
2123
2126
  const nonce = state.buffer.subarray(0, 24);
2124
2127
  const msg = state.buffer.subarray(state.start, state.end);
2125
2128
  const cipher = state.buffer.subarray(state.start);
2126
2129
  holepunchPayload.encode(state, payload);
2127
- sodium$1.randombytes_buf(nonce);
2128
- sodium$1.crypto_secretbox_easy(cipher, msg, nonce, this._sharedSecret);
2130
+ sodium.randombytes_buf(nonce);
2131
+ sodium.crypto_secretbox_easy(cipher, msg, nonce, this._sharedSecret);
2129
2132
  return state.buffer;
2130
2133
  }
2131
2134
  token(addr) {
2132
- const out = b4a$6.allocUnsafe(32);
2133
- sodium$1.crypto_generichash(out, b4a$6.from(addr.host), this._localSecret);
2135
+ const out = b4a.allocUnsafe(32);
2136
+ sodium.crypto_generichash(out, b4a.from(addr.host), this._localSecret);
2134
2137
  return out;
2135
2138
  }
2136
2139
  };
2137
2140
  }));
2138
- //#endregion
2139
- //#region ../../node_modules/hyperdht/lib/nat.js
2141
+ // ../../node_modules/hyperdht/lib/nat.js
2140
2142
  var require_nat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2141
2143
  var { FIREWALL } = require_constants();
2142
2144
  module.exports = class Nat {
@@ -2284,15 +2286,14 @@ var require_nat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2284
2286
  });
2285
2287
  }
2286
2288
  }));
2287
- //#endregion
2288
- //#region ../../node_modules/hyperdht/lib/holepuncher.js
2289
+ // ../../node_modules/hyperdht/lib/holepuncher.js
2289
2290
  var require_holepuncher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2290
- var b4a$5 = __require("b4a");
2291
+ var b4a = __require("b4a");
2291
2292
  var Nat = require_nat();
2292
2293
  var Sleeper = require_sleeper();
2293
2294
  var { FIREWALL } = require_constants();
2294
2295
  var BIRTHDAY_SOCKETS = 256;
2295
- var HOLEPUNCH = b4a$5.from([0]);
2296
+ var HOLEPUNCH = b4a.from([0]);
2296
2297
  var HOLEPUNCH_TTL = 5;
2297
2298
  var DEFAULT_TTL = 64;
2298
2299
  var MAX_REOPENS = 3;
@@ -2571,11 +2572,10 @@ var require_holepuncher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2571
2572
  }
2572
2573
  function noop() {}
2573
2574
  }));
2574
- //#endregion
2575
- //#region ../../node_modules/hyperdht/lib/relay-connection.js
2575
+ // ../../node_modules/hyperdht/lib/relay-connection.js
2576
2576
  var require_relay_connection = /* @__PURE__ */ __commonJSMin(((exports) => {
2577
- var b4a$4 = __require("b4a");
2578
- var safetyCatch$3 = __require("safety-catch");
2577
+ var b4a = __require("b4a");
2578
+ var safetyCatch = __require("safety-catch");
2579
2579
  exports.clearRelayTimeout = clearRelayTimeout;
2580
2580
  exports.closeRelayConnection = closeRelayConnection;
2581
2581
  exports.confirmDirectUpgrade = confirmDirectUpgrade;
@@ -2606,13 +2606,13 @@ var require_relay_connection = /* @__PURE__ */ __commonJSMin(((exports) => {
2606
2606
  rawStream.on("data", ondirect);
2607
2607
  rawStream.on("message", ondirect);
2608
2608
  rawStream.once("close", cleanup);
2609
- if (rawStream.trySend) rawStream.trySend(b4a$4.alloc(0));
2609
+ if (rawStream.trySend) rawStream.trySend(b4a.alloc(0));
2610
2610
  };
2611
2611
  if (!remoteChanging) {
2612
2612
  confirm();
2613
2613
  return;
2614
2614
  }
2615
- remoteChanging.then(confirm).catch(safetyCatch$3);
2615
+ remoteChanging.then(confirm).catch(safetyCatch);
2616
2616
  }
2617
2617
  function destroyRelayConnection(connectionOrHandshake) {
2618
2618
  const socket = resetRelayConnection(connectionOrHandshake);
@@ -2627,14 +2627,13 @@ var require_relay_connection = /* @__PURE__ */ __commonJSMin(((exports) => {
2627
2627
  return socket;
2628
2628
  }
2629
2629
  }));
2630
- //#endregion
2631
- //#region ../../node_modules/hyperdht/lib/server.js
2630
+ // ../../node_modules/hyperdht/lib/server.js
2632
2631
  var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2633
- var { EventEmitter: EventEmitter$1 } = __require("events");
2634
- var safetyCatch$2 = __require("safety-catch");
2635
- var NoiseSecretStream$1 = __require("@hyperswarm/secret-stream");
2636
- var b4a$3 = __require("b4a");
2637
- var relay$1 = __require("blind-relay");
2632
+ var { EventEmitter } = __require("events");
2633
+ var safetyCatch = __require("safety-catch");
2634
+ var NoiseSecretStream = __require("@hyperswarm/secret-stream");
2635
+ var b4a = __require("b4a");
2636
+ var relay = __require("blind-relay");
2638
2637
  var NoiseWrap = require_noise_wrap();
2639
2638
  var Announcer = require_announcer();
2640
2639
  var { FIREWALL, ERROR } = require_constants();
@@ -2647,7 +2646,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2647
2646
  var HANDSHAKE_CLEAR_WAIT = 1e4;
2648
2647
  var HANDSHAKE_INITIAL_TIMEOUT = 1e4;
2649
2648
  var RELAY_RECOVERY_WAIT = 3e4;
2650
- module.exports = class Server extends EventEmitter$1 {
2649
+ module.exports = class Server extends EventEmitter {
2651
2650
  constructor(dht, opts = {}) {
2652
2651
  super();
2653
2652
  this.dht = dht;
@@ -2687,16 +2686,16 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2687
2686
  }
2688
2687
  async suspend({ log = noop } = {}) {
2689
2688
  log("Suspending hyperdht server");
2690
- if (this._listening !== null) await this._listening;
2691
- log("Suspending hyperdht server (post listening)");
2692
2689
  this.suspended = true;
2693
2690
  this._clearAll();
2694
- return this._announcer ? this._announcer.suspend({ log }) : Promise.resolve();
2691
+ if (this._announcer) await this._announcer.suspend({ log });
2692
+ if (this._listening !== null) await this._listening;
2693
+ log("Suspending hyperdht server (post listening)");
2695
2694
  }
2696
2695
  async resume() {
2697
- if (this._listening !== null) await this._listening;
2698
2696
  this.suspended = false;
2699
- return this._announcer ? this._announcer.resume() : Promise.resolve();
2697
+ if (this._listening !== null) await this._listening;
2698
+ if (this._announcer && !this.suspended) this._announcer.resume();
2700
2699
  }
2701
2700
  address() {
2702
2701
  if (!this._keyPair) return null;
@@ -2729,10 +2728,11 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2729
2728
  this.emit("close");
2730
2729
  return;
2731
2730
  }
2731
+ if (this._announcer) this._announcer.stop().catch(noop);
2732
2732
  try {
2733
2733
  await this._listening;
2734
2734
  } catch (err) {
2735
- safetyCatch$2(err);
2735
+ safetyCatch(err);
2736
2736
  }
2737
2737
  this._gc();
2738
2738
  this._clearAll();
@@ -2763,7 +2763,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2763
2763
  try {
2764
2764
  await this.dht.bind();
2765
2765
  if (this._closing) return;
2766
- for (const s of this.dht.listening) if (s._keyPair && b4a$3.equals(s._keyPair.publicKey, keyPair.publicKey)) throw KEYPAIR_ALREADY_USED();
2766
+ for (const s of this.dht.listening) if (s._keyPair && b4a.equals(s._keyPair.publicKey, keyPair.publicKey)) throw KEYPAIR_ALREADY_USED();
2767
2767
  this.target = unslabbedHash(keyPair.publicKey);
2768
2768
  this._keyPair = keyPair;
2769
2769
  this._announcer = new Announcer(this.dht, keyPair, this.target, opts);
@@ -2773,7 +2773,8 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2773
2773
  onpeerhandshake: this._onpeerhandshake.bind(this),
2774
2774
  onpeerholepunch: this._onpeerholepunch.bind(this)
2775
2775
  });
2776
- this._localAddresses().catch(safetyCatch$2);
2776
+ this._localAddresses().catch(safetyCatch);
2777
+ if (this.suspended) await this._announcer.suspend();
2777
2778
  await this._announcer.start();
2778
2779
  } catch (err) {
2779
2780
  await this._stopListening();
@@ -2781,8 +2782,6 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2781
2782
  throw err;
2782
2783
  }
2783
2784
  if (this._closing) return;
2784
- if (this.suspended) await this._announcer.suspend();
2785
- if (this._closing) return;
2786
2785
  if (this.dht.destroyed) throw NODE_DESTROYED();
2787
2786
  if (this.pool) this.pool._attachServer(this);
2788
2787
  this.emit("listening");
@@ -2810,6 +2809,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2810
2809
  firewalled: true,
2811
2810
  clearing: null,
2812
2811
  replyFromPuncher: false,
2812
+ lanPending: false,
2813
2813
  onsocket: null,
2814
2814
  aborted: false,
2815
2815
  activeHolepunchRequests: 0,
@@ -2828,7 +2828,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2828
2828
  try {
2829
2829
  remotePayload = await handshake.recv(noise);
2830
2830
  } catch (err) {
2831
- safetyCatch$2(err);
2831
+ safetyCatch(err);
2832
2832
  this._clearLater(hs, id, k);
2833
2833
  return null;
2834
2834
  }
@@ -2839,7 +2839,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2839
2839
  try {
2840
2840
  hs.firewalled = await this.firewall(handshake.remotePublicKey, remotePayload, clientAddress);
2841
2841
  } catch (err) {
2842
- safetyCatch$2(err);
2842
+ safetyCatch(err);
2843
2843
  }
2844
2844
  if (this._closing || this.suspended || hs.firewalled) {
2845
2845
  this._clearLater(hs, id, k);
@@ -2882,6 +2882,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2882
2882
  hs.rawStream.on("close", onrawstreamclose);
2883
2883
  hs.onsocket = (socket, port, host) => {
2884
2884
  if (hs.rawStream === null) return;
2885
+ hs.lanPending = false;
2885
2886
  clearRelayRecovery(hs);
2886
2887
  this._clearLater(hs, id, k);
2887
2888
  if (hs.prepunching) {
@@ -2915,7 +2916,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2915
2916
  }
2916
2917
  const relayAddresses = this.relayAddresses;
2917
2918
  const relayThrough = selectRelay(this.relayThrough);
2918
- if (relayThrough) hs.relayToken = relay$1.token();
2919
+ if (relayThrough) hs.relayToken = relay.token();
2919
2920
  try {
2920
2921
  hs.reply = await handshake.send({
2921
2922
  error,
@@ -2939,7 +2940,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2939
2940
  relayAddresses: relayAddresses.length ? relayAddresses : null
2940
2941
  });
2941
2942
  } catch (err) {
2942
- safetyCatch$2(err);
2943
+ safetyCatch(err);
2943
2944
  if (hs.rawStream) hs.rawStream.destroy();
2944
2945
  this._clearLater(hs, id, k);
2945
2946
  return null;
@@ -2963,6 +2964,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2963
2964
  }
2964
2965
  if (relayThrough || remotePayload.relayThrough) this._relayConnection(hs, relayThrough, remotePayload, h);
2965
2966
  const onabort = () => {
2967
+ hs.lanPending = false;
2966
2968
  hs.aborted = true;
2967
2969
  clearRelayRecovery(hs);
2968
2970
  if (hs.prepunching) clearTimeout(hs.prepunching);
@@ -2983,6 +2985,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2983
2985
  if (clientAddresses.length > 0 && this._shareLocalAddress) {
2984
2986
  const myAddresses = await this._localAddresses();
2985
2987
  if (Holepuncher.matchAddress(myAddresses, clientAddresses)) {
2988
+ hs.lanPending = true;
2986
2989
  hs.payload = new SecurePayload(h.holepunchSecret);
2987
2990
  setupHolepuncher(this.dht, hs, remotePayload.firewall, onabort);
2988
2991
  hs.prepunching = setTimeout(onabort, HANDSHAKE_INITIAL_TIMEOUT);
@@ -3018,7 +3021,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3018
3021
  this._connects.delete(k);
3019
3022
  }
3020
3023
  async _onpeerhandshake({ noise, peerAddress }, req) {
3021
- const k = b4a$3.toString(noise, "hex");
3024
+ const k = b4a.toString(noise, "hex");
3022
3025
  let p = this._connects.get(k);
3023
3026
  if (!p) {
3024
3027
  p = this._addHandshake(k, noise, peerAddress || req.from, req, !peerAddress);
@@ -3048,7 +3051,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3048
3051
  return this._abort(h);
3049
3052
  }
3050
3053
  const token = h.payload.token(peerAddress);
3051
- const echoed = isServerRelay && !!remoteToken && b4a$3.equals(token, remoteToken);
3054
+ const echoed = isServerRelay && !!remoteToken && b4a.equals(token, remoteToken);
3052
3055
  if (req.socket === p.socket) p.nat.add(req.to, req.from);
3053
3056
  if (round >= h.round) {
3054
3057
  h.round = round;
@@ -3066,7 +3069,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3066
3069
  if (!p.remoteHolepunching && !stable) {
3067
3070
  stable = await p.analyze(true);
3068
3071
  if (p.destroyed) return null;
3069
- if (!stable) return this._abort(h);
3072
+ if (!stable && !h.lanPending) return this._abort(h);
3070
3073
  }
3071
3074
  if (isConsistent(p.nat.firewall) && remoteAddress && hasSameAddr(p.nat.addresses, remoteAddress)) {
3072
3075
  await p.ping(peerAddress);
@@ -3164,7 +3167,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3164
3167
  token = remotePayload.relayThrough.token;
3165
3168
  }
3166
3169
  const relaySocket = this.dht.connect(publicKey);
3167
- const relayClient = relay$1.Client.from(relaySocket, { id: relaySocket.publicKey });
3170
+ const relayClient = relay.Client.from(relaySocket, { id: relaySocket.publicKey });
3168
3171
  hs.relayToken = token;
3169
3172
  hs.relaySocket = relaySocket;
3170
3173
  hs.relayClient = relayClient;
@@ -3178,6 +3181,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3178
3181
  return;
3179
3182
  }
3180
3183
  hs.relayPaired = true;
3184
+ hs.lanPending = false;
3181
3185
  this.dht.stats.relaying.successes++;
3182
3186
  if (hs.prepunching) clearTimeout(hs.prepunching);
3183
3187
  hs.prepunching = null;
@@ -3241,7 +3245,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3241
3245
  return new NoiseWrap(keyPair, remotePublicKey);
3242
3246
  }
3243
3247
  function defaultCreateSecretStream(isInitiator, rawStream, opts) {
3244
- return new NoiseSecretStream$1(isInitiator, rawStream, opts);
3248
+ return new NoiseSecretStream(isInitiator, rawStream, opts);
3245
3249
  }
3246
3250
  function setupHolepuncher(dht, hs, remoteFirewall, onabort) {
3247
3251
  if (hs.puncher) return;
@@ -3263,8 +3267,7 @@ var require_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3263
3267
  }
3264
3268
  function noop() {}
3265
3269
  }));
3266
- //#endregion
3267
- //#region ../../node_modules/hyperdht/lib/semaphore.js
3270
+ // ../../node_modules/hyperdht/lib/semaphore.js
3268
3271
  var require_semaphore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3269
3272
  var DONE = Promise.resolve(true);
3270
3273
  var DESTROYED = Promise.resolve(false);
@@ -3322,14 +3325,13 @@ var require_semaphore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3322
3325
  }
3323
3326
  };
3324
3327
  }));
3325
- //#endregion
3326
- //#region ../../node_modules/hyperdht/lib/connect.js
3328
+ // ../../node_modules/hyperdht/lib/connect.js
3327
3329
  var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3328
3330
  var NoiseSecretStream = __require("@hyperswarm/secret-stream");
3329
- var b4a$2 = __require("b4a");
3331
+ var b4a = __require("b4a");
3330
3332
  var relay = __require("blind-relay");
3331
3333
  var { isReserved, isBogon } = __require("bogon");
3332
- var safetyCatch$1 = __require("safety-catch");
3334
+ var safetyCatch = __require("safety-catch");
3333
3335
  var unslab = __require("unslab");
3334
3336
  var Semaphore = require_semaphore();
3335
3337
  var NoiseWrap = require_noise_wrap();
@@ -3344,7 +3346,7 @@ var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3344
3346
  var HyperDHTAddress = __require("hyperdht-address");
3345
3347
  module.exports = function connect(dht, publicKey, opts = {}) {
3346
3348
  const pool = opts.pool || null;
3347
- const { key, nodes: providedNodes } = HyperDHTAddress.decode(b4a$2.isBuffer(publicKey) ? publicKey : decode(publicKey));
3349
+ const { key, nodes: providedNodes } = HyperDHTAddress.decode(b4a.isBuffer(publicKey) ? publicKey : decode(publicKey));
3348
3350
  publicKey = key;
3349
3351
  if (pool && pool.has(publicKey)) return pool.get(publicKey);
3350
3352
  publicKey = unslab(publicKey);
@@ -3363,7 +3365,7 @@ var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3363
3365
  }
3364
3366
  if (pool) pool._attachStream(encryptedSocket, false);
3365
3367
  const c = {
3366
- id: b4a$2.toString(publicKey, "hex"),
3368
+ id: b4a.toString(publicKey, "hex"),
3367
3369
  dht,
3368
3370
  session: dht.session(),
3369
3371
  relayAddresses: opts.relayAddresses,
@@ -3718,7 +3720,7 @@ var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3718
3720
  payload: remotePayload
3719
3721
  };
3720
3722
  if (error !== ERROR.NONE) throw REMOTE_ABORTED("Remote aborted with error code " + error);
3721
- const echoed = !!(remoteToken && payload.token && b4a$2.equals(remoteToken, payload.token));
3723
+ const echoed = !!(remoteToken && payload.token && b4a.equals(remoteToken, payload.token));
3722
3724
  c.puncher.updateRemote({
3723
3725
  punching,
3724
3726
  firewall,
@@ -3854,7 +3856,7 @@ var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3854
3856
  remoteToken: null
3855
3857
  });
3856
3858
  } catch (err) {
3857
- safetyCatch$1(err);
3859
+ safetyCatch(err);
3858
3860
  }
3859
3861
  destroyPuncher(c);
3860
3862
  maybeDestroyEncryptedSocket(c, err);
@@ -3936,8 +3938,7 @@ var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3936
3938
  }
3937
3939
  function noop() {}
3938
3940
  }));
3939
- //#endregion
3940
- //#region ../../node_modules/hyperdht/lib/raw-stream-set.js
3941
+ // ../../node_modules/hyperdht/lib/raw-stream-set.js
3941
3942
  var require_raw_stream_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3942
3943
  module.exports = class RawStreamSet {
3943
3944
  constructor(dht) {
@@ -3980,11 +3981,10 @@ var require_raw_stream_set = /* @__PURE__ */ __commonJSMin(((exports, module) =>
3980
3981
  }
3981
3982
  };
3982
3983
  }));
3983
- //#endregion
3984
- //#region ../../node_modules/hyperdht/lib/connection-pool.js
3984
+ // ../../node_modules/hyperdht/lib/connection-pool.js
3985
3985
  var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
3986
3986
  var EventEmitter = __require("events");
3987
- var b4a$1 = __require("b4a");
3987
+ var b4a = __require("b4a");
3988
3988
  var errors = require_errors();
3989
3989
  module.exports = class ConnectionPool extends EventEmitter {
3990
3990
  constructor(dht) {
@@ -3995,7 +3995,7 @@ var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) =
3995
3995
  this._connections = /* @__PURE__ */ new Map();
3996
3996
  }
3997
3997
  _attachServer(server) {
3998
- const keyString = b4a$1.toString(server.publicKey, "hex");
3998
+ const keyString = b4a.toString(server.publicKey, "hex");
3999
3999
  this._servers.set(keyString, server);
4000
4000
  server.on("close", () => {
4001
4001
  this._servers.delete(keyString);
@@ -4006,7 +4006,7 @@ var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) =
4006
4006
  _attachStream(stream, opened) {
4007
4007
  const existing = this.get(stream.remotePublicKey);
4008
4008
  if (existing) {
4009
- if (stream.isInitiator === existing.isInitiator || b4a$1.compare(stream.publicKey, stream.remotePublicKey) > 0) {
4009
+ if (stream.isInitiator === existing.isInitiator || b4a.compare(stream.publicKey, stream.remotePublicKey) > 0) {
4010
4010
  let closed = false;
4011
4011
  const onclose = () => {
4012
4012
  closed = true;
@@ -4021,7 +4021,7 @@ var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) =
4021
4021
  return;
4022
4022
  }
4023
4023
  const session = new ConnectionRef(this, stream);
4024
- const keyString = b4a$1.toString(stream.remotePublicKey, "hex");
4024
+ const keyString = b4a.toString(stream.remotePublicKey, "hex");
4025
4025
  if (opened) {
4026
4026
  this._connections.set(keyString, session);
4027
4027
  stream.on("close", () => {
@@ -4050,11 +4050,11 @@ var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) =
4050
4050
  return this._connections.values();
4051
4051
  }
4052
4052
  has(publicKey) {
4053
- const keyString = b4a$1.toString(publicKey, "hex");
4053
+ const keyString = b4a.toString(publicKey, "hex");
4054
4054
  return this._connections.has(keyString) || this._connecting.has(keyString);
4055
4055
  }
4056
4056
  get(publicKey) {
4057
- const keyString = b4a$1.toString(publicKey, "hex");
4057
+ const keyString = b4a.toString(publicKey, "hex");
4058
4058
  return (this._connections.get(keyString) || this._connecting.get(keyString))?._stream || null;
4059
4059
  }
4060
4060
  };
@@ -4076,10 +4076,9 @@ var require_connection_pool = /* @__PURE__ */ __commonJSMin(((exports, module) =
4076
4076
  };
4077
4077
  function noop() {}
4078
4078
  }));
4079
- //#endregion
4080
- //#region ../../native/transports/hyperdht/redial.mjs
4079
+ // ../../native/transports/hyperdht/redial.mjs
4081
4080
  var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
4082
- var DHT$1 = __require("dht-rpc");
4081
+ var DHT = __require("dht-rpc");
4083
4082
  var sodium = __require("sodium-universal");
4084
4083
  var c = __require("compact-encoding");
4085
4084
  var b4a = __require("b4a");
@@ -4097,11 +4096,11 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4097
4096
  var ConnectionPool = require_connection_pool();
4098
4097
  var { STREAM_NOT_CONNECTED } = require_errors();
4099
4098
  var DEFAULTS = {
4100
- ...DHT$1.DEFAULTS,
4099
+ ...DHT.DEFAULTS,
4101
4100
  connectionKeepAlive: 5e3,
4102
4101
  randomPunchInterval: 2e4
4103
4102
  };
4104
- var HyperDHT = class extends DHT$1 {
4103
+ var HyperDHT = class extends DHT {
4105
4104
  constructor(opts = {}) {
4106
4105
  const port = opts.port || 49737;
4107
4106
  const bootstrap = opts.bootstrap || BOOTSTRAP_NODES;
@@ -4273,6 +4272,7 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4273
4272
  const dht = this;
4274
4273
  const userCommit = opts.commit || noop;
4275
4274
  const signUnannounce = opts.signUnannounce || Persistent.signUnannounce;
4275
+ const force = !!opts.force;
4276
4276
  if (this._persistent !== null) this._persistent.unannounce(target, keyPair.publicKey);
4277
4277
  opts = {
4278
4278
  ...opts,
@@ -4295,7 +4295,7 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4295
4295
  for (let i = 0; !found && i < data.peers.length; i++) found = b4a.equals(data.peers[i].publicKey, keyPair.publicKey);
4296
4296
  if (!found) return data;
4297
4297
  if (!data.from.id) return data;
4298
- unannounces.push(dht._requestUnannounce(keyPair, dht, target, data.token, data.from, signUnannounce).catch(safetyCatch));
4298
+ unannounces.push(dht._requestUnannounce(keyPair, dht, target, data.token, data.from, signUnannounce, force).catch(safetyCatch));
4299
4299
  return data;
4300
4300
  }
4301
4301
  }
@@ -4305,13 +4305,15 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4305
4305
  announce(target, keyPair, relayAddresses, opts = {}) {
4306
4306
  const signAnnounce = opts.signAnnounce || Persistent.signAnnounce;
4307
4307
  const bump = opts.bump || 0;
4308
+ const lookup = opts.lookup;
4308
4309
  opts = {
4309
4310
  ...opts,
4310
- commit
4311
+ commit,
4312
+ forwardCommit: true
4311
4313
  };
4312
4314
  return opts.clear ? this.lookupAndUnannounce(target, keyPair, opts) : this.lookup(target, opts);
4313
4315
  function commit(reply, dht) {
4314
- return dht._requestAnnounce(keyPair, dht, target, reply.token, reply.from, relayAddresses, signAnnounce, bump);
4316
+ return dht._requestAnnounce(keyPair, dht, target, reply.token, reply.from, relayAddresses, signAnnounce, bump, lookup === void 0 ? !reply.value : !!lookup);
4315
4317
  }
4316
4318
  }
4317
4319
  async immutableGet(target, opts = {}) {
@@ -4493,7 +4495,7 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4493
4495
  createRawStream(opts) {
4494
4496
  return this.rawStreams.add(opts);
4495
4497
  }
4496
- async _requestAnnounce(keyPair, dht, target, token, from, relayAddresses, sign, bump) {
4498
+ async _requestAnnounce(keyPair, dht, target, token, from, relayAddresses, sign, bump, lookup) {
4497
4499
  const ann = {
4498
4500
  peer: {
4499
4501
  publicKey: keyPair.publicKey,
@@ -4501,7 +4503,8 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4501
4503
  },
4502
4504
  refresh: null,
4503
4505
  signature: null,
4504
- bump
4506
+ bump,
4507
+ lookup: !!lookup
4505
4508
  };
4506
4509
  ann.signature = await sign(target, token, from.id, ann, keyPair);
4507
4510
  const value = c.encode(m.announce, ann);
@@ -4512,7 +4515,7 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4512
4515
  value
4513
4516
  }, from);
4514
4517
  }
4515
- async _requestUnannounce(keyPair, dht, target, token, from, sign) {
4518
+ async _requestUnannounce(keyPair, dht, target, token, from, sign, force) {
4516
4519
  const unann = {
4517
4520
  peer: {
4518
4521
  publicKey: keyPair.publicKey,
@@ -4527,7 +4530,7 @@ var import_hyperdht = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e
4527
4530
  target,
4528
4531
  command: COMMANDS.UNANNOUNCE,
4529
4532
  value
4530
- }, from);
4533
+ }, from, { retry: !force });
4531
4534
  }
4532
4535
  register(name, plugin) {
4533
4536
  this.plugins.set(name, plugin);
@@ -4712,8 +4715,7 @@ function redial(dialOnce, { waitMs = PREFACE_WAIT_MS, maxWaitMs = PREFACE_MAX_WA
4712
4715
  attempt();
4713
4716
  });
4714
4717
  }
4715
- //#endregion
4716
- //#region ../../native/transports/hyperdht/endpoint.mjs
4718
+ // ../../native/transports/hyperdht/endpoint.mjs
4717
4719
  var MAX_FRAME = 61440;
4718
4720
  /** The top bit of a frame's length word: the frame is a binary message, not UTF-8 text (WISP 103). */
4719
4721
  var BINARY = 2147483648;
@@ -5046,7 +5048,6 @@ async function createHyperEndpoint(seed, options = {}) {
5046
5048
  }
5047
5049
  };
5048
5050
  }
5049
- //#endregion
5050
5051
  export { MAX_FRAME, createHyperEndpoint };
5051
5052
 
5052
- //# sourceMappingURL=endpoint-DarqblYE.js.map
5053
+ //# sourceMappingURL=endpoint-B0vE5ojY.js.map