@yume-chan/scrcpy 0.0.17 → 0.0.19

package/CHANGELOG.json

@@ -1,6 +1,42 @@
 {
   "name": "@yume-chan/scrcpy",
   "entries": [
+    {
+      "version": "0.0.19",
+      "tag": "@yume-chan/scrcpy_v0.0.19",
+      "date": "Sun, 09 Apr 2023 05:55:33 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Change `AdbScrcpyClient#pushServer` to take a `ReadableStream<Uint8Array>` instead of returning a `WritableStream<Uint8Array>`"
+          },
+          {
+            "comment": "Add `AdbReverseNotSupportedError` handling and automatically switch to forward tunnel in `AdbScrcpyClient`."
+          },
+          {
+            "comment": "Update `AndroidKeyCode` enum to align with Web `KeyboardEvent.code`"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.18",
+      "tag": "@yume-chan/scrcpy_v0.0.18",
+      "date": "Wed, 25 Jan 2023 21:33:49 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Move `@yume-chan/adb` to `peerDependencies`"
+          },
+          {
+            "comment": "Add support for Scrcpy server version 1.25"
+          },
+          {
+            "comment": "Add support for `SetClipboard` control message and `AckClipboard` device message"
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.17",
       "tag": "@yume-chan/scrcpy_v0.0.17",
@@ -56,7 +92,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for new option of 1.24"
+            "comment": "Add support for Scrcpy server version 1.24"
           }
         ]
       }
@@ -68,7 +104,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for 1.23"
+            "comment": "Add support for Scrcpy server version 1.23"
           }
         ]
       }
@@ -86,7 +122,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for 1.22 new server options"
+            "comment": "Add support for Scrcpy server version 1.22"
           },
           {
             "comment": "Update to use Web Streams API"

package/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Change Log - @yume-chan/scrcpy
 
-This log was last generated on Tue, 18 Oct 2022 09:32:30 GMT and should not be manually modified.
+This log was last generated on Sun, 09 Apr 2023 05:55:33 GMT and should not be manually modified.
+
+## 0.0.19
+Sun, 09 Apr 2023 05:55:33 GMT
+
+### Updates
+
+- Change `AdbScrcpyClient#pushServer` to take a `ReadableStream<Uint8Array>` instead of returning a `WritableStream<Uint8Array>`
+- Add `AdbReverseNotSupportedError` handling and automatically switch to forward tunnel in `AdbScrcpyClient`.
+- Update `AndroidKeyCode` enum to align with Web `KeyboardEvent.code`
+
+## 0.0.18
+Wed, 25 Jan 2023 21:33:49 GMT
+
+### Updates
+
+- Move `@yume-chan/adb` to `peerDependencies`
+- Add support for Scrcpy server version 1.25
+- Add support for `SetClipboard` control message and `AckClipboard` device message
 
 ## 0.0.17
 Tue, 18 Oct 2022 09:32:30 GMT
@@ -32,14 +50,14 @@ Sat, 30 Apr 2022 14:05:48 GMT
 
 ### Updates
 
-- Add support for new option of 1.24
+- Add support for Scrcpy server version 1.24
 
 ## 0.0.13
 Thu, 28 Apr 2022 01:23:53 GMT
 
 ### Updates
 
-- Add support for 1.23
+- Add support for Scrcpy server version 1.23
 
 ## 0.0.12
 Sun, 03 Apr 2022 11:18:47 GMT
@@ -51,7 +69,7 @@ Sun, 03 Apr 2022 10:54:15 GMT
 
 ### Updates
 
-- Add support for 1.22 new server options
+- Add support for Scrcpy server version 1.22
 - Update to use Web Streams API
 - Improve compatibility with Node.js 12 ESM format
 - Workaround a issue with server crash on Samsung ROM (https://github.com/Genymobile/scrcpy/issues/2841)

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2022 Simon Chan
+Copyright (c) 2020-2023 Simon Chan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,7 +6,7 @@ It's compatible with the official Scrcpy server binaries.
 
 **WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
 
-- [Transport agnostic](#transport-agnostic)
+- [Basic information](#basic-information)
 - [Prepare server binary](#prepare-server-binary)
   - [`fetch-scrcpy-server`](#fetch-scrcpy-server)
   - [Use the server binary](#use-the-server-binary)
@@ -15,7 +15,7 @@ It's compatible with the official Scrcpy server binaries.
     - [Webpack 4](#webpack-4)
     - [Webpack 5](#webpack-5)
   - [Read the server version](#read-the-server-version)
-- [Option versions](#option-versions)
+- [Server versions](#server-versions)
 - [Use with `@yume-chan/adb`](#use-with-yume-chanadb)
   - [Push server binary](#push-server-binary)
   - [Start server on device](#start-server-on-device)
@@ -23,17 +23,25 @@ It's compatible with the official Scrcpy server binaries.
   - [Parsing video packets](#parsing-video-packets)
   - [Sending control messages](#sending-control-messages)
   - [Reading device messages](#reading-device-messages)
-- [Consume the streams](#consume-the-streams)
+- [Always read the streams](#always-read-the-streams)
 - [Video stream](#video-stream)
 - [Decode video stream](#decode-video-stream)
 
-## Transport agnostic
+## Basic information
 
-It was initially designed to be used with `@yume-chan/adb`, but now it can also to used with any other transportation.
+Although Scrcpy doesn't install any App on the device, it does have a server binary executable to be run on the device.
+
+With the official Scrcpy client and server, the client uses ADB to transfer the server binary file to the device, run it, and communicate with it via ADB tunnel (the bootstrap process).
+
+This package provides types that can serialize and deserialize Scrcpy protocol messages, but it generally requires you to do the bootstrapping and provide the data stream to the server.
+
+If you are also using `@yume-chan/adb`, this package has a helper class that can complete the bootstrap process using it, doing what the official client does.
+
+**NOTE:** `@yume-chan/adb` is a peer dependency, you need to install it yourself. Only those types whose names begin with `Adb` requires `@yume-chan/adb`.
 
 ## Prepare server binary
 
-Scrcpy needs a server binary running on the device in order to work. This package doesn't ship with one.
+This package doesn't include the server binary. It's compatible with many versions of the official server binary, but may not work with future versions due to protocol changes.
 
 You can download the server binary from official releases (https://github.com/Genymobile/scrcpy/releases), or use the built-in `fetch-scrcpy-server` script to automate the process.
 
@@ -41,9 +49,11 @@ The server binary is subject to [Apache License 2.0](https://github.com/Genymobi
 
 ### `fetch-scrcpy-server`
 
-To use the script, first add `gh-release-fetch@3` to `devDependencies` of your `package.json`. It's an optional peer dependency fpr minimized download size.
+This package includes a script that downloads the server binary from official releases for you.
 
-Then you can invoke it in a terminal:
+The `gh-release-fetch@3` package is a peer dependency for this script, thus requires separated installation.
+
+Usage:
 
 ```
 $ npx fetch-scrcpy-server <version>
@@ -52,14 +62,14 @@ $ npx fetch-scrcpy-server <version>
 For example:
 
 ```
-$ npx fetch-scrcpy-server 1.24
+$ npx fetch-scrcpy-server 1.25
 ```
 
-You can also add it to the `postinstall` script in your `package.json`. After that, running `npm install` will automatically invoke the script.
+It can also be added to the `postinstall` script in `package.json`, so running `npm install` will automatically invoke the script:
 
 ```json
 "scripts": {
-    "postinstall": "fetch-scrcpy-server 1.24",
+    "postinstall": "fetch-scrcpy-server 1.25",
 },
 ```
 
@@ -67,34 +77,41 @@ The server binary will be named `bin/scrcpy-server` in this package's installati
 
 ### Use the server binary
 
-The server binary file needs to be embedded into your application, the exact method depends on the runtime.
+The server binary file needs to be embedded into your application, the exact method depends on the bundler and runtime.
 
 To name a few:
 
 #### Node.js CommonJS
 
 ```ts
-const fs = require('fs');
-const path: string = require.resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const fs = require("fs");
+const path: string = require.resolve("@yume-chan/scrcpy/bin/scrcpy-server"); // Or your own server binary path
 const buffer: Buffer = fs.readFileSync(path);
 ```
 
 #### Node.js ES module
 
 ```ts
-import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
 
-const path: string = createRequire(import.meta.url).resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const path: string = createRequire(import.meta.url).resolve(
+    "@yume-chan/scrcpy/bin/scrcpy-server"
+); // Or your own server binary path
 const buffer: Buffer = await fs.readFile(path);
 ```
 
 Currently, ES Module doesn't have a `resolve` function like `require.resolve` in CommonJS, so `createRequire` is used to create a CommonJS resolver.
 
-`import.meta.resolve` (https://github.com/whatwg/html/pull/5572) is a proposal that fills this gap. Node.js already has experimental support for it behind a flag. See https://nodejs.org/api/esm.html#importmetaresolvespecifier-parent for more information.
+Or with the `--experimental-import-meta-resolve` command line flag, you can use `import.meta.resolve`:
 
 ```ts
-const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
+import fs from "node:fs/promises";
+
+const path: string = await import.meta.resolve(
+    "@yume-chan/scrcpy/bin/scrcpy-server"
+);
+const buffer: Buffer = await fs.readFile(path);
 ```
 
 #### Webpack 4
@@ -102,8 +119,10 @@ const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
 Requires installing and configuring file-loader (https://v4.webpack.js.org/loaders/file-loader/)
 
 ```ts
-import SCRCPY_SERVER_URL from '@yume-chan/scrcpy/bin/scrcpy-server'; // Or your own server binary path
-const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+import SCRCPY_SERVER_URL from "@yume-chan/scrcpy/bin/scrcpy-server"; // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then((response) =>
+    response.arrayBuffer()
+);
 ```
 
 #### Webpack 5
@@ -111,8 +130,13 @@ const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.array
 Requires configuring Asset Modules (https://webpack.js.org/guides/asset-modules/)
 
 ```ts
-const SCRCPY_SERVER_URL = new URL('@yume-chan/scrcpy/bin/scrcpy-server', import.meta.url); // Or your own server binary path
-const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+const SCRCPY_SERVER_URL = new URL(
+    "@yume-chan/scrcpy/bin/scrcpy-server",
+    import.meta.url
+); // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then((response) =>
+    response.arrayBuffer()
+);
 ```
 
 ### Read the server version
@@ -120,14 +144,14 @@ const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.array
 The correct version number is required to launch the server, so `fetch-scrcpy-server` also writes the version number to `bin/version.js`.
 
 ```js
-import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
+import SCRCPY_SERVER_VERSION from "@yume-chan/scrcpy/bin/version.js";
 
-console.log(SCRCPY_SERVER_VERSION); // "1.24"
+console.log(SCRCPY_SERVER_VERSION); // "1.25"
 ```
 
-## Option versions
+## Server versions
 
-Scrcpy server options changes over time, and some of them are not backwards compatible. This package provides option types for each version (or range). Using wrong option version usually results in errors.
+Scrcpy protocol change over time, and are usually not backwards compatible. This package supports multiple server versions (or ranges), and uses different option types to choose different behaviors. Using incorrect option version usually results in errors.
 
 The latest one may continue to work for future server versions, but there is no guarantee.
 
@@ -139,47 +163,56 @@ The latest one may continue to work for future server versions, but there is no
 | 1.22      | `ScrcpyOptions1_22` |
 | 1.23      | `ScrcpyOptions1_23` |
 | 1.24      | `ScrcpyOptions1_24` |
+| 1.25      | `ScrcpyOptions1_25` |
 
-When using `AdbScrcpyClient`, there is another `AdbScrcpyOptions` contains `@yume-chan/adb` related logics:
+When using `AdbScrcpyClient`, there are `AdbScrcpyOptions` containing `@yume-chan/adb` specific options:
 
 | Version   | Type                   |
 | --------- | ---------------------- |
 | 1.16~1.21 | `AdbScrcpyOptions1_16` |
-| 1.22~1.24 | `AdbScrcpyOptions1_22` |
+| 1.22~1.25 | `AdbScrcpyOptions1_22` |
 
 ## Use with `@yume-chan/adb`
 
-The the server binary needs to be copied to the device and run on it.
+`@yume-chan/adb` is a TypeScript ADB implementation that can run on Web browser. It can be used to bootstrap the server on a device.
 
 ### Push server binary
 
-The `Adb#sync()#write()` method can be used to push files to the device. Read more at `@yume-chan/adb`'s documentation (https://github.com/yume-chan/ya-webadb/tree/main/libraries/adb#readme).
+The `AdbSync#write()` method can be used to push files to the device. Read more at `@yume-chan/adb`'s documentation (https://github.com/yume-chan/ya-webadb/tree/main/libraries/adb#readme).
 
 This package also provides the `AdbScrcpyClient.pushServer()` static method as a shortcut, plus it will automatically close the `AdbSync` object on completion.
 
-Example using `write()`:
+Example using a `ReadableStream`:
 
 ```ts
-import { AdbScrcpyClient } from '@yume-chan/scrcpy';
+import { WrapReadableStream } from "@yume-chan/adb";
+import { AdbScrcpyClient } from "@yume-chan/scrcpy";
 
-const stream: WritableStream<Uint8Array> = AdbScrcpyClient.pushServer(adb);
-const writer = stream.getWriter();
-await writer.write(new Uint8Array(buffer));
-await writer.close();
+await AdbScrcpyClient.pushServer(
+    adb,
+    await fetch(SCRCPY_SERVER_URL).then(
+        // `WrapReadableStream` is required because native `ReadableStream` (from `fetch`)
+        // doesn't support `pipeTo()` non-native `WritableStream`s
+        // (`@yume-chan/adb` is using `web-streams-polyfill`)
+        (response) => new WrapReadableStream(response.body)
+    )
+);
 ```
 
-Example using `pipeTo()`:
+Example using an `ArrayBuffer`:
 
 ```ts
-import { WrapReadableStream } from '@yume-chan/adb';
-import { AdbScrcpyClient } from '@yume-chan/scrcpy';
-
-await fetch(SCRCPY_SERVER_URL)
-    // `WrapReadableStream` is required because native `ReadableStream` (from `fetch`)
-    // doesn't support `pipeTo()` non-native `WritableStream`s
-    // (`@yume-chan/adb` is using `web-streams-polyfill`)
-    .then(response => new WrapReadableStream(response.body))
-    .then(stream => stream.pipeTo(AdbScrcpyClient.pushServer(adb)));
+import { AdbScrcpyClient } from "@yume-chan/scrcpy";
+
+await AdbScrcpyClient.pushServer(
+    adb,
+    new ReadableStream({
+        start(controller) {
+            controller.enqueue(new Uint8Array(buffer));
+            controller.end();
+        },
+    })
+);
 ```
 
 ### Start server on device
@@ -187,22 +220,33 @@ await fetch(SCRCPY_SERVER_URL)
 To start the server, use the `AdbScrcpyClient.start()` method. It automatically sets up port forwarding, launches the server, and connects to it.
 
 ```js
-import { AdbScrcpyClient, AdbScrcpyOptions1_22, DEFAULT_SERVER_PATH, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
-import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
+import {
+    AdbScrcpyClient,
+    AdbScrcpyOptions1_22,
+    DEFAULT_SERVER_PATH,
+    ScrcpyOptions1_24,
+} from "@yume-chan/scrcpy";
+import SCRCPY_SERVER_VERSION from "@yume-chan/scrcpy/bin/version.js";
 
 const client: AdbScrcpyClient = await AdbScrcpyClient.start(
     adb,
     DEFAULT_SERVER_PATH,
-    SCRCPY_SERVER_VERSION, // Or provide your own version number
-    new AdbScrcpyOptions1_22(ScrcpyOptions1_24({
-        // options
-    }))
+    // If server binary was downloaded manually, must provide the correct version
+    SCRCPY_SERVER_VERSION,
+    new AdbScrcpyOptions1_22(
+        ScrcpyOptions1_24({
+            // options
+        })
+    )
 );
 
 const stdout: ReadableStream<string> = client.stdout;
-const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = client.videoStream;
-const controlMessageSerializer: ScrcpyControlMessageSerializer | undefined = client.controlMessageSerializer;
-const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined = client.deviceMessageStream;
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> =
+    client.videoStream;
+const controlMessageSerializer: ScrcpyControlMessageSerializer | undefined =
+    client.controlMessageSerializer;
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined =
+    client.deviceMessageStream;
 
 // to stop the server
 client.close();
@@ -216,8 +260,10 @@ If you push, start and connect to the server yourself, you can still use this pa
 
 Requires a `ReadableStream<Uint8Array>` that reads from the video socket, preserving packet boundaries.
 
+**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
+
 ```ts
-import { ScrcpyOptions1_24, ScrcpyVideoStreamPacket } from '@yume-chan/scrcpy';
+import { ScrcpyOptions1_24, ScrcpyVideoStreamPacket } from "@yume-chan/scrcpy";
 
 const videoStream: ReadableStream<Uint8Array>; // get the stream yourself
 
@@ -225,7 +271,8 @@ const options = new ScrcpyOptions1_24({
     // use the same version and options
 });
 
-const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = videoStream.pipeThrough(options.createVideoStreamTransformer());
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> =
+    videoStream.pipeThrough(options.createVideoStreamTransformer());
 // Read from `videoPacketStream`
 ```
 
@@ -236,15 +283,21 @@ Requires a `WritableStream<Uint8Array>` that writes to the control socket.
 Control socket is optional if control is not enabled. Video socket and control socket can run completely separately.
 
 ```ts
-import { ScrcpyControlMessageSerializer, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+import {
+    ScrcpyControlMessageSerializer,
+    ScrcpyOptions1_24,
+} from "@yume-chan/scrcpy";
 
-const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined; // get the stream yourself
 
 const options = new ScrcpyOptions1_24({
     // use the same version and options
 });
 
-const controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
+const controlMessageSerializer = new ScrcpyControlMessageSerializer(
+    controlStream.writable,
+    options
+);
 // Call methods on `controlMessageSerializer`
 controlMessageSerializer.injectText("Hello World!");
 ```
@@ -253,17 +306,27 @@ controlMessageSerializer.injectText("Hello World!");
 
 Requires a `ReadableStream<Uint8Array>` that reads from the control socket.
 
+**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
+
 ```ts
-import { ScrcpyDeviceMessageDeserializeStream, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+import {
+    ScrcpyDeviceMessageDeserializeStream,
+    ScrcpyOptions1_24,
+} from "@yume-chan/scrcpy";
 
-const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined; // get the stream yourself
 
-const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> =
+    controlStream.readable.pipeThrough(
+        new ScrcpyDeviceMessageDeserializeStream()
+    );
 ```
 
-## Consume the streams
+## Always read the streams
 
-Any `ReadableStream` (`stdout` when using `AdbScrcpyClient`, `videoPacketStream` and `deviceMessageStream` when control is enabled) must be continuously read (even if you don't care about the data), otherwise the whole connection will stall.
+In Web Streams API, `ReadableStream` will block its upstream when too many chunks are kept not read. If multiple streams are from the same upstream source, block one stream means blocking all of them.
+
+For Scrcpy, usually all streams are originated from the same ADB connection (either USB or TCP), so it's important to always read from all streams, even if you don't care about their data.
 
 ```ts
 // when using `AdbScrcpyClient`
@@ -271,9 +334,9 @@ stdout
     .pipeTo(
         new WritableStream<string>({
             write: (line) => {
-                // Handle the stdout line
+                // Handle or ignore the stdout line
             },
-        }),
+        })
     )
     .catch(() => {})
     .then(() => {
@@ -281,19 +344,23 @@ stdout
     });
 
 videoPacketStream
-    .pipeTo(new WritableStream<ScrcpyVideoStreamPacket>({
-        write: (packet) => {
-            // Handle the video packet
-        },
-    }))
+    .pipeTo(
+        new WritableStream<ScrcpyVideoStreamPacket>({
+            write: (packet) => {
+                // Handle or ignore the video packet
+            },
+        })
+    )
     .catch(() => {});
 
 deviceMessageStream
-    .pipeTo(new WritableStream<ScrcpyDeviceMessage>({
-        write: (message) => {
-            // Handle the device message
-        },
-    }))
+    .pipeTo(
+        new WritableStream<ScrcpyDeviceMessage>({
+            write: (message) => {
+                // Handle or ignore the device message
+            },
+        })
+    )
     .catch(() => {});
 ```
 
@@ -303,12 +370,12 @@ The data from `videoPacketStream` has two types: `configuration` and `frame`. So
 
 ```ts
 export interface ScrcpyVideoStreamConfigurationPacket {
-    type: 'configuration';
+    type: "configuration";
     data: H264Configuration;
 }
 
 export interface ScrcpyVideoStreamFramePacket {
-    type: 'frame';
+    type: "frame";
     keyframe?: boolean | undefined;
     pts?: bigint | undefined;
     data: Uint8Array;
@@ -319,8 +386,8 @@ When `sendFrameMeta: false` is set, `videoPacketStream` only contains `frame` pa
 
 Otherwise, both `configuration` and `frame` packets are available.
 
-* `configuration` packets contain the parsed SPS data, and can be used to initialize a video decoder.
-* `pts` (and `keyframe` field from server version 1.23) fields in `frame` packets are available to help decode the video.
+-   `configuration` packets contain the parsed SPS data, and can be used to initialize a video decoder.
+-   `pts` (and `keyframe` field from server version 1.23) fields in `frame` packets are available to help decode the video.
 
 ## Decode video stream
 

package/bin/version.d.ts

@@ -1 +1 @@
-export default '1.24';
+export default '2.0';

package/bin/version.js

@@ -1 +1 @@
-export default '1.24';
+export default '2.0';