Merge remote-tracking branch 'origin/master'

# Conflicts:
#	build.gradle.kts

.gitignore

@@ -45,3 +45,4 @@ out/
 .kotlin
 /.idea/workspace.xml
 /.gigaide/gigaide.properties
+local.properties

.idea/artifacts/kiloparsec_js_0_4_1.xml

@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="kiloparsec-js-0.4.1">
+    <output-path>$PROJECT_DIR$/build/libs</output-path>
+    <root id="archive" name="kiloparsec-js-0.4.1.jar">
+      <element id="module-output" name="kiloparsec.jsMain" />
+    </root>
+  </artifact>
+</component>

.idea/artifacts/kiloparsec_js_0_4_3.xml

@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="kiloparsec-js-0.4.3">
+    <output-path>$PROJECT_DIR$/build/libs</output-path>
+    <root id="archive" name="kiloparsec-js-0.4.3.jar">
+      <element id="module-output" name="kiloparsec.jsMain" />
+    </root>
+  </artifact>
+</component>

.idea/artifacts/kiloparsec_jvm_0_4_1.xml

@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="kiloparsec-jvm-0.4.1">
+    <output-path>$PROJECT_DIR$/build/libs</output-path>
+    <root id="archive" name="kiloparsec-jvm-0.4.1.jar">
+      <element id="module-output" name="kiloparsec.jvmMain" />
+    </root>
+  </artifact>
+</component>

.idea/artifacts/kiloparsec_jvm_0_4_3.xml

@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="kiloparsec-jvm-0.4.3">
+    <output-path>$PROJECT_DIR$/build/libs</output-path>
+    <root id="archive" name="kiloparsec-jvm-0.4.3.jar">
+      <element id="module-output" name="kiloparsec.jvmMain" />
+    </root>
+  </artifact>
+</component>

.idea/codeStyles/Project.xml

@@ -1,5 +1,29 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <DBN-PSQL>
+      <case-options enabled="true">
+        <option name="KEYWORD_CASE" value="lower" />
+        <option name="FUNCTION_CASE" value="lower" />
+        <option name="PARAMETER_CASE" value="lower" />
+        <option name="DATATYPE_CASE" value="lower" />
+        <option name="OBJECT_CASE" value="preserve" />
+      </case-options>
+      <formatting-settings enabled="false" />
+    </DBN-PSQL>
+    <DBN-SQL>
+      <case-options enabled="true">
+        <option name="KEYWORD_CASE" value="lower" />
+        <option name="FUNCTION_CASE" value="lower" />
+        <option name="PARAMETER_CASE" value="lower" />
+        <option name="DATATYPE_CASE" value="lower" />
+        <option name="OBJECT_CASE" value="preserve" />
+      </case-options>
+      <formatting-settings enabled="false">
+        <option name="STATEMENT_SPACING" value="one_line" />
+        <option name="CLAUSE_CHOP_DOWN" value="chop_down_if_statement_long" />
+        <option name="ITERATION_ELEMENTS_WRAPPING" value="chop_down_if_not_single" />
+      </formatting-settings>
+    </DBN-SQL>
     <ScalaCodeStyleSettings>
       <option name="MULTILINE_STRING_CLOSING_QUOTES_ON_NEW_LINE" value="true" />
     </ScalaCodeStyleSettings>

.idea/misc.xml

@@ -1,9 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="corretto-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" project-jdk-name="corretto-17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -1,6 +1,9 @@
 # Kiloparsec
 
-__Recommended version is `0.4.1`: to keep the code compatible with current and further versions we
+> 0.7.0-SNAPSHOT is recommended for newer builds; due to extremely poor Kotlin time migration architecture, on Apple targets it is the only working version.
+
+
+__Recommended version is `0.6.8`: to keep the code compatible with current and further versions we
 ask to upgrade to `0.4.2` at least.__ Starting from this version some package names are changed for
 better clarity and fast UDP endpoints are added.
 
@@ -8,20 +11,26 @@ The new generation of __PARanoid SECurity__ protocol, advanced, faster, more sec
 block device" transport to the same local interface. Out if the box it
 provides the following transports:
 
-| name              | JVM    | JS | native |
-|-------------------|--------|----|--------|
-| TCP/IP server     | ✓      |    | 0.2.6+ |
-| TCP/IP client     | ✓      |    | 0.2.6+ |
-| UDP server        | 0.3.2+ |    | 0.3.2+ |
-| UDP client        | 0.3.2+ |    | 0.3.2+ |
-| Websockets server | ✓      |    |        |
-| Websockets client | ✓      | ✓  | ✓      |
+| name              | JVM  | JS  | wasmJS  | native |
+|-------------------|:----:|:---:|:-------:|:------:|
+| TCP/IP server     |  ✓   |     |         |   ✓    |
+| TCP/IP client     |  ✓   |     |         |   ✓    |
+| UDP server        |  ✓   |     |         |   ✓    |
+| UDP client        |  ✓   |     |         |   ✓    |
+| Websockets server |  ✓   |     |         |        |
+| Websockets client |  ✓   |  ✓  |    ✓    |   ✓    |
 
 ### Note on version compatibility
 
-Version 0.5.1 could be backward incompatible due to upgrade of the crypto2.
+We recommend using `0.6.12`
 
-Protocols >= 0.3.0 are not binary compatible with previous version due to more compact binary
+Since version 0.6.9 websocket protocol supports both text and binary frames; old clients are backward compatible with
+mew servers, but new clients only can work with older servers only in default binary frame mode. Upgrade also your
+servers to get better websocket compatibility[^1].
+
+Version 0.5.1 could be backward incompatible due to the upgrade of the crypto2.
+
+Protocols >= 0.3.0 are not binary compatible with the previous version due to a more compact binary
 format. The format from 0.3.0 onwards is supposed to keep compatible.
 
 #### ID calculation algorithm is changed since 0.4.1
@@ -41,10 +50,13 @@ We recommend to upgrade to 0.4+ ASAP as public/shared key id derivation method w
 
 ## TCP/IP and UDP transports
 
-These are the fastest based on async socket implementation of ktor client. They works everywhere but JS target as
-there is currently no widely adopted sockets for browser javascript.
+These are the fastest based on async socket implementation of a ktor client. They work everywhere but JS target as
+there are currently no widely adopted sockets for browser JavaScript.
 
-While UDP is faster than TCP/IP, it is less reliable, especially with commands and return values that serializes to more than 240 bytes approx, and has no retransmission facilities (use TCP!). UDP though shines when all you need is to [push](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-remote-interface/push.html) with little or no data in it.
+While UDP is faster than TCP/IP, it is less reliable, especially with commands and return values that serialize to more
+than 240 bytes approx, and has no retransmission facilities (use TCP!). UDP, though, shines when all you need is
+to [push](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-remote-interface/push.html) with
+little or no data in it.
 
 ## Websockets server
 
@@ -61,7 +73,7 @@ It is slower than TCP or UDP, but it works on literally all platforms. See the s
 
 # Usage
 
-The library should be used as maven dependency, not as source.
+The library should be used as a maven dependency, not as source.
 
 ## Adding dependency
 
@@ -82,12 +94,12 @@ It could be, depending on your project structure, something like:
 ```kotlin
 val commonMain by getting {
     dependencies {
-        api("net.sergeych:kiloparsec:0.4.1")
+        api("net.sergeych:kiloparsec:0.6.8")
     }
 }
 ```
 
-## Create shared interface for your server and the client
+## Create a shared interface for your server and the client
 
 It could be a multiplatform library that exports it or just a shared or copied source file declaring structures
 and functions available, like:
@@ -138,10 +150,11 @@ assertEquals(FooArgs("bar", 117), client.call(cmdGetFoo))
 
 ```
 
-## Create ktor-based server
+## Create a ktor-based server
 
-Normally server side needs some session. It is convenient and avoid sending repeating data on each request speeding up
-the protocol. With KILOPARSEC, it is rather basic operation:
+Normally the server side needs some session. It is convenient and avoids sending repeating data on each request speeding
+up
+the protocol. With KILOPARSEC, it is a rather basic operation:
 
 ~~~kotlin
 // Our session just keeps Foo for cmd{Get|Set}Foo:
@@ -168,11 +181,11 @@ val ns: NettyApplicationEngine = embeddedServer(Netty, port = 8080, host = "0.0.
 
 ~~~
 
-## Create TCP/IP client and server
+## Create a TCP / IP client and server
 
 Using plain TCP/IP is even simpler, and it works way faster than websocket one, and is _the same
-protected as `wss://` (and `ws://`) variant above due to same kiloparsec encryption in both cases. Still, a TCP/IP
-client is not available in Javascript browser targets and custom TCP ports could often be blocked by firewalls.
+protected as `wss://` (and `ws://`) the variant above due to same kiloparsec encryption in both cases. Still, a TCP/IP
+client is not available in JavaScript browser targets, and custom TCP ports could often be blocked by firewalls.
 
 Documentation is available in samples here:
 
@@ -180,11 +193,13 @@ Documentation is available in samples here:
 
 - [TCP/IP client](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-client/index.html)
 
-In short, there are two functions that implements asynchronous TCP/IP transport on all platforms buy JS:
+In short, there are two functions that implement asynchronous TCP/IP transport on all platforms buy JS:
 
-- [acceptTcpDevice](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec.adapter/accept-tcp-device.html?query=fun%20acceptTcpDevice(port:%20Int):%20Flow%3CInetTransportDevice%3E) to create a server
+- [acceptTcpDevice](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec.adapter/accept-tcp-device.html?query=fun%20acceptTcpDevice(port:%20Int):%20Flow%3CInetTransportDevice%3E)
+  to create a server
 
-- [connectTcpDevice](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec.adapter/connect-tcp-device.html) to connect to the server
+- [connectTcpDevice](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec.adapter/connect-tcp-device.html)
+  to connect to the server
 
 ## UDP client and server
 
@@ -197,36 +212,50 @@ Is very much straightforward, same as with TCP/IP:
 
 #### Command size
 
-Each command invocation and result are packed in a separate UDP diagram using effective binary packing. 
-Thus, for the best results commands and results should be relatively short, best to fit into 240 bytes. While bigger datagrams are often transmitted successfully, the probability of the effective transmission drops with the size.
+Each command invocation and result are packed in a separate UDP diagram using effective binary packing.
+Thus, for the best results commands and results should be relatively short, best to fit into 240 bytes. While bigger
+datagrams are often transmitted successfully, the probability of the effective transmission drops with the size.
 
 Kiloparsec UDP transport does not retransmit not delivered packets. Use TCP/IP or websocket if it is a concern.
 
-For the best results we recommend using [push](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-remote-interface/index.html#1558240250%2FFunctions%2F788909594) for remote interfaces with UDP.
+For the best results, we recommend
+using [push](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-remote-interface/index.html#1558240250%2FFunctions%2F788909594)
+for remote interfaces with UDP.
 
 #### Timeouts
 
 As Datagrams do not form protocol itself, kiloparsec issues pings when no data is circulated between parties.
-When no pings are received long enough, kiloparsec connection is closed. There are `maxInactivityTimeout` in all
+When no pings are received long enough, the kiloparsec connection is closed. There are `maxInactivityTimeout` in all
 relevant functions and constructors.
 
 Client should not issue pings manually.
 
 ## Reusing code between servers
 
-The same instance of the [KiloInterface](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-interface/index.html?query=open%20class%20KiloInterface%3CS%3E%20:%20LocalInterface%3CKiloScope%3CS%3E%3E) could easily be reused with all instances of servers with different protocols.
+The same instance of
+the [KiloInterface](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-interface/index.html?query=open%20class%20KiloInterface%3CS%3E%20:%20LocalInterface%3CKiloScope%3CS%3E%3E)
+could easily be reused with all instances of servers with different protocols.
 
-This is a common proactive to create a business logic in a `KiloInterface`, then create a TCP/IP and Websocket servers passing the same instance of the logic to both.
+This is a common practice to create a business logic in a `KiloInterface`, then create a TCP/IP and Websocket servers
+passing the same instance of the logic to both.
 
 ## Note on the server identification
 
-We do not recommend to rely on TLS (HTTPS://, WSS://) host identification solely, in the modern world there is
+We do not recommend relying on TLS (HTTPS://, WSS://) host identification solely; in the modern world there is
 a high probability of attacks on unfriendly (in respect to at least some of your users) states to the SSL certificates
-chain, in which case the [MITM attack] and spoofing will be undetected. Check the [remoteId](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-client/remote-id.html?query=suspend%20fun%20remoteId():%20VerifyingPublicKey?) in your client on each connection and provide the safe [serverSecretKey](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-server/index.html) when creating a server.
+chain, in which case the [MITM attack] and spoofing will be undetected. Check
+the [remoteId](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-client/remote-id.html?query=suspend%20fun%20remoteId():%20VerifyingPublicKey?)
+in your client on each connection and provide the
+safe [serverSecretKey](https://code.sergeych.net/docs/kiloparsec/kiloparsec/net.sergeych.kiloparsec/-kilo-server/index.html)
+when creating a server.
 
-This will effectively protect against certificate chain spoofing in the case of the application installed from the trusted source.
+This will effectively protect against certificate chain spoofing in the case of the application installed from the
+trusted source.
 
-__Important note__. The web application could not be completely secured this way unless is loaded from the IP-address, as the DNS could be spoofed the same, especially when used with `Cloudflare` or other CDN that can transparently substitute the whole site. For applications, we strongly recommend not to use CDN except your own, controlled ones. You generally can't neither detect nor repel [MITM attack] performed from _any single cloudflare 'ray'_.
+__Important note__. The web application could not be completely secured this way unless is loaded from the IP-address,
+as the DNS could be spoofed the same, especially when used with `Cloudflare` or other CDN that can transparently
+substitute the whole site. For applications, we strongly recommend not using CDN except your own, controlled ones. You
+generally can't neither detect nor repel [MITM attack] performed from _any single cloudflare 'ray'_.
 
 ## See also:
 
@@ -235,25 +264,25 @@ __Important note__. The web application could not be completely secured this way
 
 # Details
 
-It is not compatible with parsec family and no more based on an Universa crypto library. To better fit
+It is not compatible with Parsec family and no more based on the Universa crypto library. To better fit
 the modern state of threats and rate of cyber crimes, KiloParsec uses more encryption and random key exchange on each
 and every connection (while parsec caches session keys to avoid time-consuming keys exchange). For the same reason,
-keys cryptography for session is shifted to use ed25519 curves which are supposed to provide agreeable strength with
-enough speed to protect every connection with a unique new keys. Also, we completely get rid of SHA2.
+keys cryptography for session is shifted to use ed25519 curves, which are supposed to provide agreeable strength with
+enough speed to protect every connection with unique new keys. Also, we completely get rid of SHA2.
 
 Kiloparsec also uses a denser binary format [bipack](https://gitea.sergeych.net/SergeychWorks/mp_bintools), no more
 key-values,
 which reveals much less on the inner data structure, providing advanced
 typed RPC interfaces with kotlinx.serialization. There is also Rust
 implementation [bipack_ru](https://gitea.sergeych.net/DiWAN/bipack_ru).
-The architecture allows connecting same functional interfaces to several various type channels at once.
+The architecture allows connecting the same functional interfaces to several various type channels at once.
 
 Also, the difference from parsecs is that there are no more unencrypted layer commands available to users.
 All RPC is performed over the encrypted connection.
 
 # Technical description
 
-Kiloparsec is a full-duplex fully async (coroutine based) Remote Procedure Call protocol with typed parameters
+Kiloparsec is a full-duplex fully async (coroutine-based) Remote Procedure Call protocol with typed parameters
 and support for serializing exceptions (e.g. exception thrown while executing remote command will be caught and
 rethrown at the caller context).
 
@@ -262,16 +291,22 @@ Integrated tools to prevent MITM attacks include also non-transferred independen
 independently on the ends and is never transferred with the network. Comparing it somehow (visually, with QR code, etc.)
 could add a very robust guarantee of the connection safety and ingenuity.
 
-Kiloparsec has built-in completely asynchronous (coroutine based top-down) transport layer based on TCP (JVM only as for
+Kiloparsec has a built-in completely asynchronous (coroutine-based top-down) transport layer based on TCP (JVM only as
+for
 now) and the same async Websocket-based transport based on KTOR. Websocket client is multiplatform, though the server is
 JVM only insofar.
 
 # Licensing
 
-This is work in progress, not yet moved to public domain;
- you need to obtain a license from https://8-rays.dev or [Sergey Chernov]. For open source projects it will most be free on some special terms.
+This is a work in progress, not yet moved to the public domain;
+you need to obtain a license from https://8-rays.dev or [Sergey Chernov]. For open source projects it will most be free
+on some special terms.
 
-It will be moved to open source; we also guarantee that it will be moved to open source immediately if the software export restrictions will be lifted. We do not support such practices here at 8-rays.dev.
+It will be moved to open source; we also guarantee that it will be moved to open source immediately if the software
+export restrictions are lifted. We do not support such practices here at 8-rays.dev.
 
 [MITM]: https://en.wikipedia.org/wiki/Man-in-the-middle_attack
-[Sergey Chernov]: https://t.me/real_sergeych
+
+[Sergey Chernov]: https://t.me/real_sergeych
+[^1]: On some new Xiaomi phones we found problems with websocket binary frames, probably in ktor; use text frames
+otherwise. 

build.gradle.kts

@@ -8,15 +8,18 @@
  * real dot sergeych at gmail.
  */
 
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+
 plugins {
-    kotlin("multiplatform") version "2.1.0"
-    id("org.jetbrains.kotlin.plugin.serialization") version "2.1.0"
+    kotlin("multiplatform") version "2.2.21"
+    id("org.jetbrains.kotlin.plugin.serialization") version "2.2.21"
+    id("com.android.library") version "8.7.2" apply true
     `maven-publish`
     id("org.jetbrains.dokka") version "1.9.20"
 }
 
 group = "net.sergeych"
-version = "0.6.3"
+version = "0.7.0-SNAPSHOT"
 
 repositories {
     mavenCentral()
@@ -27,40 +30,51 @@ repositories {
 }
 
 kotlin {
-    jvmToolchain(17)
+    jvmToolchain(21)
     jvm()
     js {
-        browser {
-        }
+        browser()
         nodejs()
     }
-//    macosArm64()
-//    iosX64()
-//    iosArm64()
-//    iosSimulatorArm64()
     linuxX64()
     linuxArm64()
-//    macosX64()
-//    macosX64()
-    mingwX64()
-//    @OptIn(ExperimentalWasmDsl::class)
-//    wasmJs()
 
-    val ktor_version = "3.1.0"
+    macosArm64()
+    macosX64()
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+
+    mingwX64()
+
+    androidTarget()
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+    }
+
+    val ktor_version = "3.1.1"
 
     sourceSets {
         all {
             languageSettings.optIn("kotlinx.serialization.ExperimentalSerializationApi")
             languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
             languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
+            languageSettings.optIn("kotlin.time.ExperimentalTime")
+
         }
 
         val commonMain by getting {
             dependencies {
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
-                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.2")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
                 api("io.ktor:ktor-client-core:$ktor_version")
-                api("net.sergeych:crypto2:0.7.4-SNAPSHOT")
+                api("net.sergeych:crypto2:0.9.0")
+            }
+        }
+        val androidMain by getting {
+            dependencies {
+                implementation("io.ktor:ktor-client-okhttp:$ktor_version")
             }
         }
         val ktorSocketMain by creating {
@@ -72,8 +86,8 @@ kotlin {
         val commonTest by getting {
             dependencies {
                 implementation(kotlin("test"))
-                implementation("org.slf4j:slf4j-simple:2.0.9")
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
+                implementation("org.slf4j:slf4j-simple:2.0.17")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
             }
         }
         val ktorSocketTest by creating {
@@ -92,34 +106,33 @@ kotlin {
         val jvmTest by getting {
             dependsOn(ktorSocketTest)
         }
-
         val jsMain by getting {
             dependencies {
                 implementation("io.ktor:ktor-client-js:$ktor_version")
             }
         }
         val jsTest by getting
-//        val macosArm64Main by getting {
-//            dependsOn(ktorSocketMain)
-//        }
-//        val macosArm64Test by getting {
-//            dependsOn(ktorSocketTest)
-//        }
-//        val macosX64Main by getting {
-//            dependsOn(ktorSocketMain)
-//        }
-//        val iosX64Main by getting {
-//            dependsOn(ktorSocketMain)
-//        }
-//        val iosX64Test by getting {
-//            dependsOn(ktorSocketTest)
-//        }
-//        val iosArm64Main by getting {
-//            dependsOn(ktorSocketMain)
-//        }
-//        val iosArm64Test by getting {
-//            dependsOn(ktorSocketTest)
-//        }
+        val macosArm64Main by getting {
+            dependsOn(ktorSocketMain)
+        }
+        val macosArm64Test by getting {
+            dependsOn(ktorSocketTest)
+        }
+        val macosX64Main by getting {
+            dependsOn(ktorSocketMain)
+        }
+        val iosX64Main by getting {
+            dependsOn(ktorSocketMain)
+        }
+        val iosX64Test by getting {
+            dependsOn(ktorSocketTest)
+        }
+        val iosArm64Main by getting {
+            dependsOn(ktorSocketMain)
+        }
+        val iosArm64Test by getting {
+            dependsOn(ktorSocketTest)
+        }
         val linuxArm64Main by getting {
             dependsOn(ktorSocketMain)
         }
@@ -133,26 +146,27 @@ kotlin {
             dependsOn(ktorSocketTest)
         }
     }
+}
 
-    publishing {
-        val mavenToken by lazy {
-            File("${System.getProperty("user.home")}/.gitea_token").readText()
-        }
-        repositories {
-            maven {
-                credentials(HttpHeaderCredentials::class) {
-                    name = "Authorization"
-                    value = mavenToken
-                }
-                url = uri("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
-                authentication {
-                    create("Authorization", HttpHeaderAuthentication::class)
-                }
+publishing {
+    val mavenToken by lazy {
+        File("${System.getProperty("user.home")}/.gitea_token").readText()
+    }
+    repositories {
+        maven {
+            credentials(HttpHeaderCredentials::class) {
+                name = "Authorization"
+                value = mavenToken
+            }
+            url = uri("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
+            authentication {
+                create("Authorization", HttpHeaderAuthentication::class)
             }
         }
     }
 }
 
+
 tasks.dokkaHtml.configure {
     outputDirectory.set(buildDir.resolve("dokka"))
     dokkaSourceSets {
@@ -162,3 +176,15 @@ tasks.dokkaHtml.configure {
     }
 }
 
+android {
+    namespace = "net.sergeych.kiloparsec"
+    compileSdk = 34
+    defaultConfig {
+        minSdk = 24
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+}
+

gradle.properties

@@ -9,4 +9,12 @@
 #
 
 kotlin.code.style=official
-kotlin.mpp.applyDefaultHierarchyTemplate=false
+kotlin.mpp.applyDefaultHierarchyTemplate=false
+
+kotlin.daemon.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+kotlin.native.ignoreDisabledTargets=true
+
+org.gradle.parallel=true
+org.gradle.configuration-cache=true
+org.gradle.caching=true
+

gradle/wrapper/gradle-wrapper.properties

@@ -10,6 +10,6 @@
 
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle.kts

@@ -1,4 +1,4 @@
-/*
+    /*
  * Copyright (c) 2025. Sergey S. Chernov - All Rights Reserved
  *
  *  You may use, distribute and modify this code under the
@@ -10,6 +10,7 @@
 
 pluginManagement {
     repositories {
+        google()
         mavenCentral()
         gradlePluginPortal()
     }

src/commonMain/kotlin/net/sergeych/kiloparsec/Command.kt

@@ -15,12 +15,11 @@ import kotlinx.serialization.Serializable
 import net.sergeych.bintools.toDataSource
 import net.sergeych.bipack.BipackDecoder
 import net.sergeych.bipack.BipackEncoder
-import net.sergeych.kiloparsec.Command.Call
 import net.sergeych.kiloparsec.Command.Companion.unpackCall
 import net.sergeych.utools.unpack
 
 /**
- * Typesafe command definition. Command is a universal entity in Divan: it is used
+ * Typesafe command definition. Command is a universal entity in kiloparsec (and also diwan): it is used
  * in node-2-node protocols and client API, and most importantly in calling smart contract
  * methods. This is essentially a Kotlin binding to typesafe serialize command calls and
  * deserialize results.

src/commonMain/kotlin/net/sergeych/kiloparsec/KiloClient.kt

@@ -91,9 +91,11 @@ class KiloClient<S>(
                     debug { "get device and session" }
                     val client = KiloClientConnection(localInterface, kc, secretKey)
                     deferredClient.complete(client)
-                    client.run {
+                    debug { "starting client run"}
+                    val r = runCatching {  client.run {
                         _state.value = it
-                    }
+                    } }
+                    debug { "----------- client run finished: $r" }
                     resetDeferredClient()
                     debug { "client run finished" }
                 } catch (_: RemoteInterface.ClosedException) {
@@ -109,7 +111,7 @@ class KiloClient<S>(
                 _state.value = false
                 resetDeferredClient()
                 // reconnection timeout
-                delay(100)
+                delay(700)
             }
         }
 

src/commonMain/kotlin/net/sergeych/kiloparsec/KiloClientConnection.kt

@@ -49,7 +49,6 @@ class KiloClientConnection<S>(
             try {
                 // in parallel: keys and connection
                 val deferredKeyPair = async { SafeKeyExchange() }
-                debug { "opening device" }
                 debug { "got a transport device $device" }
 
 
@@ -62,10 +61,11 @@ class KiloClientConnection<S>(
                 debug { "transport started" }
 
                 val pair = deferredKeyPair.await()
-                debug { "keypair ready" }
+                debug { "keypair ready (1)" }
 
                 val serverHe = transport.call(L0Request, Handshake(1u, pair.publicKey))
 
+                debug { "got server HE (2)" }
                 val sk = pair.clientSessionKey(serverHe.publicKey)
                 var params = KiloParams(false, transport, sk, session, null, this@KiloClientConnection)
 
@@ -97,8 +97,7 @@ class KiloClientConnection<S>(
             } catch (x: CancellationException) {
                 info { "client is cancelled" }
             } catch (x: RemoteInterface.ClosedException) {
-                x.printStackTrace()
-                info { "connection closed by remote" }
+                debug { "connection closed/refused by remote" }
             } finally {
                 onConnectedStateChanged?.invoke(false)
                 job?.cancel()

src/commonMain/kotlin/net/sergeych/kiloparsec/Transport.kt

@@ -27,13 +27,12 @@ import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.serializer
 import net.sergeych.bipack.Unsigned
 import net.sergeych.crypto2.toDump
-import net.sergeych.kiloparsec.Transport.Device
 import net.sergeych.mp_logger.*
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 
 /**
- * Divan channel that operates some block [Device] exporting a given [localInterface]
+ * Kiloparsec channel that operates some block [Device] exporting a given [localInterface]
  * to remote callers. [LocalInterface] allows session managing, transmitting exceptions
  * in a scure and multiplatform way and provide local command execution (typed RPC)
  */
@@ -134,7 +133,13 @@ class Transport<S>(
         }
 
         // now we have mutex freed so we can call:
-        val r = runCatching { device.output.send(pack(b)) }
+        val r = runCatching {
+            do {
+                val cr = device.output.trySend(pack(b))
+                if( cr.isClosed ) throw ClosedSendChannelException("can't send block: channel is closed")
+                delay(100)
+            } while(!cr.isSuccess)
+        }
         if (!r.isSuccess) {
             r.exceptionOrNull()?.let {
                 exception { "failed to send output block" to it }
@@ -245,7 +250,7 @@ class Transport<S>(
                 } catch (cce: LocalInterface.BreakConnectionException) {
                     info { "closing connection by local request ($cce)" }
                     device.close()
-                } catch (t: RemoteInterface.ClosedException) {
+                } catch (_: RemoteInterface.ClosedException) {
                     // it is ok: we just exit the coroutine normally
                     // and mark we're closing
                     isClosed = true
@@ -271,7 +276,7 @@ class Transport<S>(
             }
             debug { "no more active: $isActive / ${calls.size}" }
         }
-        info { "exiting transport loop" }
+        debug { "exiting transport loop" }
     }
 
     private suspend fun send(block: Block) {

src/commonMain/kotlin/net/sergeych/kiloparsec/adapter/websocketClient.kt

@@ -20,12 +20,12 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.launch
+import kotlinx.io.IOException
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.kiloparsec.*
-import net.sergeych.mp_logger.LogTag
-import net.sergeych.mp_logger.exception
-import net.sergeych.mp_logger.info
-import net.sergeych.mp_logger.warning
+import net.sergeych.mp_logger.*
+import net.sergeych.mp_tools.decodeBase64Compact
+import net.sergeych.mp_tools.encodeToBase64Compact
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
 
@@ -39,13 +39,14 @@ fun <S> websocketClient(
     path: String,
     clientInterface: KiloInterface<S> = KiloInterface(),
     secretKey: SigningKey? = null,
+    useTextFrames: Boolean = false,
     sessionMaker: () -> S = {
         @Suppress("UNCHECKED_CAST")
         Unit as S
     },
 ): KiloClient<S> {
     return KiloClient(clientInterface, secretKey) {
-        KiloConnectionData(websocketTransportDevice(path), sessionMaker())
+        KiloConnectionData(websocketTransportDevice(path, useTextFrames), sessionMaker())
     }
 }
 
@@ -56,7 +57,10 @@ fun <S> websocketClient(
  */
 fun websocketTransportDevice(
     path: String,
-    client: HttpClient = HttpClient { install(WebSockets) },
+    useTextFrames: Boolean = false,
+    client: HttpClient = HttpClient {
+        install(WebSockets)
+    },
 ): Transport.Device {
     var u = Url(path)
     if (u.encodedPath.length <= 1)
@@ -67,70 +71,89 @@ fun websocketTransportDevice(
     val input = Channel<UByteArray>()
     val output = Channel<UByteArray>()
     val closeHandle = CompletableDeferred<Boolean>()
+    val readyHandle = CompletableDeferred<Unit>()
+
     globalLaunch {
         val log = LogTag("KC:${counter.incrementAndGet()}")
-        client.webSocket({
-            url.protocol = u.protocol
-            url.host = u.host
-            url.port = u.port
-            url.encodedPath = u.encodedPath
-            url.parameters.appendAll(u.parameters)
-            log.info { "kiloparsec server URL: $url" }
-        }) {
-            log.info { "connected to the server" }
+        try {
+            client.webSocket({
+                url.protocol = u.protocol
+                url.host = u.host
+                url.port = u.port
+                url.encodedPath = u.encodedPath
+                url.parameters.appendAll(u.parameters)
+                log.info { "kiloparsec server URL: $url" }
+            }) {
+                log.info { "connected to the server" }
 //                println("SENDING!!!")
 //                send("Helluva")
-            launch {
-                try {
-                    for (block in output) {
-                        send(block.toByteArray())
-                    }
-                    log.info { "input is closed, closing the websocket" }
-                    if (closeHandle.isActive) closeHandle.complete(true)
-                } catch (_: ClosedSendChannelException) {
-                    log.info { "send channel closed" }
-                } catch (_: CancellationException) {
-                } catch (t: Throwable) {
-                    log.info { "unexpected exception in websock sender: ${t.stackTraceToString()}" }
-                    closeHandle.completeExceptionally(t)
-                }
-                if (closeHandle.isActive) closeHandle.complete(false)
-            }
-            launch {
-                try {
-                    for (f in incoming) {
-                        if (f is Frame.Binary) {
-                            input.send(f.readBytes().toUByteArray())
-                        } else {
-                            log.warning { "ignoring unexpected frame of type ${f.frameType}" }
+                readyHandle.complete(Unit)
+                launch {
+                    try {
+                        for (block in output) {
+                            if (useTextFrames)
+                                send(
+                                    Frame.Text(block.asByteArray().encodeToBase64Compact())
+                                )
+                            else
+                                send(block.toByteArray())
                         }
+                        log.info { "input is closed, closing the websocket" }
+                        if (closeHandle.isActive) closeHandle.complete(true)
+                    } catch (_: ClosedSendChannelException) {
+                        log.info { "send channel closed" }
+                    } catch (_: CancellationException) {
+                    } catch (t: Throwable) {
+                        log.info { "unexpected exception in websock sender: ${t.stackTraceToString()}" }
+                        closeHandle.completeExceptionally(t)
                     }
-                    if (closeHandle.isActive) closeHandle.complete(true)
-                } catch (_: CancellationException) {
-                    if (closeHandle.isActive) closeHandle.complete(false)
-                } catch (_: ClosedReceiveChannelException) {
-                    log.warning { "receive channel closed unexpectedly" }
-                    if (closeHandle.isActive) closeHandle.complete(false)
-                } catch (t: Throwable) {
-                    log.exception { "unexpected error" to t }
                     if (closeHandle.isActive) closeHandle.complete(false)
                 }
+                launch {
+                    try {
+                        for (f in incoming) {
+                            when (f) {
+                                is Frame.Binary -> input.send(f.readBytes().toUByteArray())
+                                is Frame.Text -> input.send(f.readText().decodeBase64Compact().toUByteArray())
+                                else -> log.warning { "ignoring unexpected frame of type ${f.frameType}" }
+                            }
+                        }
+                        if (closeHandle.isActive) closeHandle.complete(true)
+                    } catch (_: CancellationException) {
+                        if (closeHandle.isActive) closeHandle.complete(false)
+                    } catch (_: ClosedReceiveChannelException) {
+                        log.warning { "receive channel closed unexpectedly" }
+                        if (closeHandle.isActive) closeHandle.complete(false)
+                    } catch (t: Throwable) {
+                        log.exception { "unexpected error" to t }
+                        if (closeHandle.isActive) closeHandle.complete(false)
+                    }
+                }
+                if (!closeHandle.await()) {
+                    log.warning { "Client is closing with error" }
+                    throw RemoteInterface.ClosedException()
+                }
+                runCatching { output.close() }
+                runCatching { input.close() }
+                runCatching { close() }
             }
-            if (!closeHandle.await()) {
-                log.warning { "Client is closing with error" }
-                throw RemoteInterface.ClosedException()
-            }
-            output.close()
-            input.close()
+        } catch (x: IOException) {
+            if ("refused" in x.toString()) log.debug { "connection refused" }
+            else log.warning { "unexpected IO error $x" }
+            runCatching { output.close() }
+            runCatching { input.close() }
         }
         log.info { "closing connection" }
     }
-    val device = ProxyDevice(input, output) {
+    // Wait for connection be established or failed
+    val device = ProxyDevice(input, output, doClose = {
         // we need to explicitly close the coroutine job, or it can hang for a long time
         // leaking resources.
+        runCatching { output.close() }
+        runCatching { input.close() }
         closeHandle.complete(true)
 //            job.cancel()
-    }
+    })
     return device
 }
 

src/commonTest/kotlin/PackTest.kt

@@ -9,7 +9,6 @@
  */
 
 import kotlinx.coroutines.test.runTest
-import kotlinx.datetime.Instant
 import net.sergeych.bipack.BipackEncoder
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.KiloParams
@@ -21,6 +20,7 @@ import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 import kotlin.time.Duration.Companion.microseconds
+import kotlin.time.Instant
 
 class PackTest {
         inline fun <reified T>check(x: T?) {

src/commonTest/kotlin/TransportTest.kt

@@ -76,7 +76,8 @@ class TransportTest {
                 "p2: $it"
             }
             on(cmdSlow) {
-                delay(100)
+                // the problem: runTest() breaks delays so it is not enough
+                for( i in 0..10000) delay(1)
                 "done"
             }
         }

src/jvmMain/kotlin/net/sergeych/kiloparsec/adapter/WebsocketServer.kt

@@ -24,6 +24,8 @@ import net.sergeych.kiloparsec.KiloInterface
 import net.sergeych.kiloparsec.KiloServerConnection
 import net.sergeych.kiloparsec.RemoteInterface
 import net.sergeych.mp_logger.*
+import net.sergeych.mp_tools.decodeBase64Compact
+import net.sergeych.mp_tools.encodeToBase64Compact
 import net.sergeych.tools.AtomicCounter
 import kotlin.time.Duration.Companion.seconds
 
@@ -66,13 +68,18 @@ fun <S> Application.setupWebsocketServer(
             log.debug { "opening the connection" }
             val input = Channel<UByteArray>(256)
             val output = Channel<UByteArray>(256)
+            var useBinary: Boolean? = null
             launch {
                 log.debug { "starting output pump" }
                 while (isActive) {
                     try {
-                        send(output.receive().toByteArray())
-                    }
-                    catch(_: ClosedReceiveChannelException) {
+                        val block = output.receive()
+                        if (useBinary == false)
+                            send(block.asByteArray().encodeToBase64Compact())
+                        else
+                            send(block.toByteArray())
+
+                    } catch (_: ClosedReceiveChannelException) {
                         log.debug { "closing output pump as output channel is closed" }
                         break
                     }
@@ -91,21 +98,38 @@ fun <S> Application.setupWebsocketServer(
             }
             log.debug { "KSC started, looking for incoming frames" }
             for (f in incoming) {
-                if (f is Frame.Binary)
-                    try {
-                        input.send(f.readBytes().toUByteArray())
-                    } catch (_: RemoteInterface.ClosedException) {
-                        log.warning { "caught local closed exception (strange!), closing" }
-                        break
-                    } catch (_: ClosedReceiveChannelException) {
-                        log.info { "receive channel is closed, closing connection" }
-                        break
-                    } catch (t: Throwable) {
-                        log.exception { "unexpected exception, server connection will close" to t }
-                        break
+                try {
+                    when (f) {
+                        is Frame.Binary -> {
+                            if (useBinary == null) {
+                                log.debug { "Setting binary frame mode ------------------------------------" }
+                                useBinary = true
+                            }
+                            input.send(f.readBytes().toUByteArray())
+                        }
+
+                        is Frame.Text -> {
+                            if (useBinary == null) {
+                                log.debug { "Setting text frame mode -----------------------------------" }
+                                useBinary = false
+                            }
+                            input.send(f.readText().decodeBase64Compact().asUByteArray())
+                        }
+
+                        else -> {
+                            log.warning { "unexpected frame type ${f.frameType}, ignoring" }
+                        }
                     }
-                else
-                    log.warning { "unknown frame type ${f.frameType}, ignoring" }
+                } catch (_: RemoteInterface.ClosedException) {
+                    log.warning { "caught local closed exception (strange!), closing" }
+                    break
+                } catch (_: ClosedReceiveChannelException) {
+                    log.info { "receive channel is closed, closing connection" }
+                    break
+                } catch (t: Throwable) {
+                    log.exception { "unexpected exception, server connection will close" to t }
+                    break
+                }
             }
             log.debug { "closing the server" }
             close()

src/jvmTest/kotlin/net/sergeych/kiloparsec/ClientTest.kt

@@ -15,10 +15,13 @@ import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
+import net.sergeych.crypto2.SigningSecretKey
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.adapter.setupWebsocketServer
 import net.sergeych.kiloparsec.adapter.websocketClient
+import net.sergeych.kiloparsec.adapter.websocketTransportDevice
 import net.sergeych.mp_logger.Log
 import java.net.InetAddress
 import kotlin.random.Random
@@ -39,17 +42,18 @@ class ClientTest {
 
 
     @Test
-    fun webSocketTest() = runTest {
+    fun webSocketTest1() = runTest {
         initCrypto()
 //        fun Application.
-        val cmdClose by command<Unit,Unit>()
-        val cmdGetFoo by command<Unit,String>()
-        val cmdSetFoo by command<String,Unit>()
-        val cmdCheckConnected by command<Unit,Boolean>()
+        val cmdClose by command<Unit, Unit>()
+        val cmdGetFoo by command<Unit, String>()
+        val cmdSetFoo by command<String, Unit>()
+        val cmdCheckConnected by command<Unit, Boolean>()
 
         Log.connectConsole(Log.Level.DEBUG)
 
-        data class Session(var foo: String="not set")
+        data class Session(var foo: String = "not set")
+
         var closeCounter = 0
         val serverInterface = KiloInterface<Session>().apply {
             var connectedCalled = false
@@ -62,7 +66,7 @@ class ClientTest {
             }
         }
 
-        val port = Random.nextInt(8080,9090)
+        val port = Random.nextInt(8080, 9090)
         val ns = embeddedServer(Netty, port = port, host = "0.0.0.0", module = {
             setupWebsocketServer(serverInterface) { Session() }
         }).start(wait = false)
@@ -73,7 +77,9 @@ class ClientTest {
             client.connectedStateFlow.collect {
                 println("got: $closeCounter/$it")
                 states += it
-                if( !it) { closeCounter++ }
+                if (!it) {
+                    closeCounter++
+                }
             }
         }
         assertEquals(true, client.call(cmdCheckConnected))
@@ -94,7 +100,7 @@ class ClientTest {
         assertFalse { client.connectedStateFlow.value }
 
         // this should be run on automatically reopen connection
-        client.call(cmdSetFoo,"superbar")
+        client.call(cmdSetFoo, "superbar")
         assertTrue { client.connectedStateFlow.value }
         assertEquals("superbar", client.call(cmdGetFoo))
         client.close()
@@ -104,4 +110,101 @@ class ClientTest {
 //        println("stopped server")
 //        println("closed client")
     }
-}
+
+    @Test
+    fun webSocketTest2() = runTest {
+        initCrypto()
+//        fun Application.
+        val cmdClose by command<Unit, Unit>()
+        val cmdGetFoo by command<Unit, String>()
+        val cmdSetFoo by command<String, Unit>()
+        val cmdCheckConnected by command<Unit, Boolean>()
+
+        Log.connectConsole(Log.Level.DEBUG)
+
+        data class Session(var foo: String = "not set")
+
+        var closeCounter = 0
+        val serverInterface = KiloInterface<Session>().apply {
+            var connectedCalled = false
+            onConnected { connectedCalled = true }
+            on(cmdGetFoo) { session.foo }
+            on(cmdSetFoo) { session.foo = it }
+            on(cmdCheckConnected) { connectedCalled }
+            on(cmdClose) {
+                throw LocalInterface.BreakConnectionException()
+            }
+        }
+
+        val port = Random.nextInt(8080, 9090)
+        val ns = embeddedServer(Netty, port = port, host = "0.0.0.0", module = {
+            setupWebsocketServer(serverInterface) { Session() }
+        }).start(wait = false)
+
+        val client = websocketClient<Unit>("ws://localhost:$port/kp", useTextFrames = true)
+        val states = mutableListOf<Boolean>()
+        val collector = launch {
+            client.connectedStateFlow.collect {
+                println("got: $closeCounter/$it")
+                states += it
+                if (!it) {
+                    closeCounter++
+                }
+            }
+        }
+        assertEquals(true, client.call(cmdCheckConnected))
+        assertTrue { client.connectedStateFlow.value }
+        assertEquals("not set", client.call(cmdGetFoo))
+        client.call(cmdSetFoo, "foo")
+        assertEquals("foo", client.call(cmdGetFoo))
+
+        client.close()
+        ns.stop()
+        collector.cancel()
+
+    }
+
+
+    @Test
+    fun webSocketWaitForConnectTest() = runBlocking {
+        initCrypto()
+//        fun Application.
+        Log.connectConsole(Log.Level.DEBUG)
+
+        val clientInterface = KiloInterface<Unit>().apply {}
+
+        val port = Random.nextInt(8080, 9090)
+        var clientConnectCalls = 0
+        // It should repeatedly reconnect, and we will count:
+        KiloClient(clientInterface, SigningSecretKey.new()) {
+            clientConnectCalls++
+            KiloConnectionData(websocketTransportDevice("ws://localhost:$port/kp", true), Unit)
+        }
+        delay(1200)
+        // and check:
+//        println("connection attemtps: $clientConnectCalls")
+        assertTrue { clientConnectCalls > 1 }
+    }
+
+    @Test
+    fun webSocketWaitForConnectTest2() = runBlocking {
+        initCrypto()
+//        fun Application.
+        Log.connectConsole(Log.Level.DEBUG)
+
+        val clientInterface = KiloInterface<Unit>().apply {}
+
+        val port = Random.nextInt(8080, 9090)
+        var clientConnectCalls = 0
+        // It should repeatedly reconnect, and we will count:
+        KiloClient(clientInterface, SigningSecretKey.new()) {
+            clientConnectCalls++
+            KiloConnectionData(websocketTransportDevice("ws://localhost:$port/kp", false), Unit)
+        }
+        delay(1200)
+        // and check:
+//        println("connection attemtps: $clientConnectCalls")
+        assertTrue { clientConnectCalls > 1 }
+    }
+
+}

src/ktorSocketMain/kotlin/net/sergeych/kiloparsec/adapter/TcpProvider.kt

@@ -22,11 +22,11 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.datetime.Clock
 import net.sergeych.kiloparsec.*
 import net.sergeych.mp_logger.*
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
+import kotlin.time.Clock
 import kotlin.time.Duration.Companion.seconds
 
 private val logCounter = AtomicCounter(0)
@@ -52,7 +52,13 @@ fun acceptTcpDevice(port: Int, localInterface: String = "0.0.0.0"): Flow<InetTra
     }
 }
 
-suspend fun connectTcpDevice(address: String) = connectTcpDevice(address.toNetworkAddress())
+
+/**
+ * Connect to the TCP/IP server (see [KiloServer]) at the specified address and provide th compatible
+ * [InetTransportDevice] to use with [KiloClient]. [hostPortAddress] is a string in the form of `host:port`.
+ */
+suspend fun connectTcpDevice(hostPortAddress: String): InetTransportDevice =
+    connectTcpDevice(hostPortAddress.toNetworkAddress())
 
 /**
  * Connect to the TCP/IP server (see [KiloServer]) at the specified address and provide th compatible
@@ -134,7 +140,7 @@ private fun inetTransportDevice(
                             sockInput.readFully(data, 0, size)
                             inputBlocks.send(data.toUByteArray())
                         }
-                    } catch (e: ClosedReceiveChannelException) {
+                    } catch (_: ClosedReceiveChannelException) {
                         log.error { "closed receive channel " }
                         stop()
                         break

src/ktorSocketMain/kotlin/net/sergeych/kiloparsec/adapter/UdpSocketTransport.kt

@@ -19,13 +19,13 @@ import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import kotlinx.datetime.Clock
 import net.sergeych.kiloparsec.SyncValue
 import net.sergeych.mp_logger.Log
 import net.sergeych.mp_logger.Loggable
 import net.sergeych.mp_logger.debug
 import net.sergeych.mp_logger.exception
 import net.sergeych.mp_tools.globalLaunch
+import kotlin.time.Clock
 import kotlin.time.Duration
 
 /**
@@ -171,10 +171,10 @@ internal class UdpSocketTransport(
         while (!isClosed) {
             try {
                 server.sendBlock(UdpBlock.Data(outputDataBlocks.receive()), socketAddress)
-            } catch (e: CancellationException) {
+            } catch (_: CancellationException) {
                 // this is ok
                 break
-            } catch (e: ClosedReceiveChannelException) {
+            } catch (_: ClosedReceiveChannelException) {
                 debug { "input channel is closed, closing" }
                 close()
                 break