@statewalker/webrun-msgpack 0.1.1 → 0.3.0

package/dist/msgpack-core.d.ts

@@ -0,0 +1,70 @@
+/*!
+ * MessagePack serializer and deserializer.
+ *
+ * A TypeScript port of msgpack.js by Yves Goergen:
+ *   https://github.com/ygoe/msgpack.js
+ *   ported from commit 05733cfb43a2974cf669f0eb8693f43b548bdcd4 (2024-04-16) on `master`,
+ *   which carries three fixes that the last npm release, `@ygoe/msgpack@1.0.3`, does not.
+ * Every change made to the upstream logic is listed in this package's README, section
+ * "Provenance and credits".
+ *
+ * Original work: Copyright © 2019, Yves Goergen, https://unclassified.software/source/msgpack-js
+ * TypeScript port and modifications: Copyright (c) 2026 statewalker
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the “Software”), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/** Options for {@link serialize}. */
+export interface SerializeOptions {
+    /**
+     * Treat `data` as an array of values and concatenate their encodings, one MessagePack document
+     * after another, instead of encoding the array itself. Default: `false`.
+     */
+    multiple?: boolean;
+    /**
+     * What to write in place of a value whose type cannot be serialized (a function, a symbol, a
+     * bigint): either the replacement value itself, or a function that returns one given the
+     * original. When absent, such a value throws.
+     */
+    invalidTypeReplacement?: unknown;
+}
+/** Options for {@link deserialize}. */
+export interface DeserializeOptions {
+    /**
+     * Read every concatenated MessagePack document in the input and return them as an array.
+     * Default: `false` — read one document and ignore any bytes after it.
+     */
+    multiple?: boolean;
+}
+/** The byte shapes {@link deserialize} accepts. */
+export type MsgpackInput = Uint8Array | ArrayBuffer | ArrayLike<number>;
+/** An extension value whose type this implementation does not interpret (anything but a timestamp). */
+export interface MsgpackExtension {
+    type: number;
+    data: Uint8Array;
+}
+/**
+ * Serializes a value to a MessagePack byte array.
+ *
+ * The result is a view over a larger internal buffer; send the view, not its `.buffer`.
+ */
+export declare function serialize(data: unknown, options?: SerializeOptions): Uint8Array<ArrayBuffer>;
+/**
+ * Deserializes a MessagePack byte array to a value.
+ *
+ * `bin` values are returned as `Uint8Array` views into the input, not copies.
+ */
+export declare function deserialize(input: MsgpackInput, options?: DeserializeOptions): unknown;
+//# sourceMappingURL=msgpack-core.d.ts.map

package/dist/msgpack-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msgpack-core.d.ts","sourceRoot":"","sources":["../src/msgpack-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAExE,uGAAuG;AACvG,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,UAAU,CAAC,WAAW,CAAC,CAmQ5F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAoNtF"}

package/dist/msgpack.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Encode each value as a length-prefixed msgpack frame.
+ * Frame format: [4-byte big-endian length][msgpack bytes]
+ *
+ * The input may be synchronous (an array, a generator) or asynchronous.
+ */
+export declare function encodeMsgpack<T>(input: Iterable<T> | AsyncIterable<T>): AsyncGenerator<Uint8Array>;
+/**
+ * Decode length-prefixed msgpack frames, reassembling across chunk boundaries.
+ *
+ * The input may be synchronous (an array of chunks) or asynchronous.
+ */
+export declare function decodeMsgpack<T>(input: Iterable<Uint8Array> | AsyncIterable<Uint8Array>): AsyncGenerator<T>;
+/**
+ * Encode each Float32Array as a msgpack frame.
+ * The Float32Array is converted to a Uint8Array view (zero-copy) before encoding as msgpack bin.
+ *
+ * The input may be synchronous (an array, a generator) or asynchronous.
+ */
+export declare function encodeFloat32Arrays(input: Iterable<Float32Array> | AsyncIterable<Float32Array>): AsyncGenerator<Uint8Array>;
+/**
+ * Decode msgpack frames back to Float32Array.
+ * Each frame contains a msgpack bin value (Uint8Array), reinterpreted as Float32Array.
+ *
+ * The input may be synchronous (an array of chunks) or asynchronous.
+ */
+export declare function decodeFloat32Arrays(input: Iterable<Uint8Array> | AsyncIterable<Uint8Array>): AsyncGenerator<Float32Array>;
+//# sourceMappingURL=msgpack.d.ts.map

package/dist/msgpack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msgpack.d.ts","sourceRoot":"","sources":["../src/msgpack.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GACpC,cAAc,CAAC,UAAU,CAAC,CAS5B;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACtD,cAAc,CAAC,CAAC,CAAC,CAgBnB;AAED;;;;;GAKG;AACH,wBAAuB,mBAAmB,CACxC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,aAAa,CAAC,YAAY,CAAC,GAC1D,cAAc,CAAC,UAAU,CAAC,CAU5B;AAED;;;;;GAKG;AACH,wBAAuB,mBAAmB,CACxC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACtD,cAAc,CAAC,YAAY,CAAC,CAK9B"}

package/dist/port-codec.d.ts

@@ -0,0 +1,22 @@
+import type { PortCodec } from "@statewalker/webrun-rpc";
+/**
+ * For ports whose messages are bytes — a WebSocket, a WebRTC data channel, a
+ * LiveKit data packet.
+ *
+ * One envelope becomes one msgpack frame and one `postMessage`. There is no
+ * length prefix, because every transport this codec targets preserves message
+ * boundaries; adding one would be redundant framing on a transport that
+ * already frames. (`encodeMsgpack`/`decodeMsgpack` in this package *do* carry
+ * a length prefix — they are a stream codec for a transport with no
+ * boundaries, and are a different thing.)
+ *
+ * The transfer list is deliberately ignored: after encoding, the payload is
+ * inside the bytes, so there is nothing left to hand over.
+ *
+ * **Not interchangeable with `structuredCodec` in one respect:** msgpack drops
+ * object keys whose value is `undefined`, where structured clone preserves
+ * them. Nothing layer 2 sends depends on that distinction today, and it must
+ * not come to — see spec D16.
+ */
+export declare const msgpackCodec: PortCodec;
+//# sourceMappingURL=port-codec.d.ts.map

package/dist/port-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-codec.d.ts","sourceRoot":"","sources":["../src/port-codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,yBAAyB,CAAC;AA2BvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,EAAE,SAmB1B,CAAC"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@statewalker/webrun-msgpack",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
-  "description": "Length-prefixed MessagePack frame codec for async iterables. Streams-safe encode/decode for values and Float32Arrays.",
+  "description": "MessagePack for the wire, with no runtime dependencies: serialize/deserialize (a TypeScript port of msgpack.js), a length-prefixed stream codec for iterables (values and Float32Arrays), and msgpackCodec, a PortCodec that carries webrun-rpc port envelopes over a byte transport.",
   "homepage": "https://github.com/statewalker/webrun-wire",
   "author": {
     "name": "Mikhail Kotelnikov",
@@ -16,33 +16,41 @@
     "directory": "packages/webrun-msgpack"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@ygoe/msgpack": "^1.0.3"
+    "@statewalker/webrun-rpc": "0.4.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.8",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.14",
+    "rolldown": "^1.2.4",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "@statewalker/webrun-streams": "0.2.0",
+    "@statewalker/webrun-streams-conformance": "0.2.0"
   },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsdown",
+    "build": "rimraf dist && rolldown -c && tsc --emitDeclarationOnly --declaration",
     "dev": "tsdown --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc -p tsconfig.tests.json",
     "clean": "rimraf dist",
-    "lint": "biome check --write .",
+    "lint": "biome check src tests",
     "format": "biome format --write ."
   }
 }

package/src/index.ts

@@ -4,3 +4,12 @@ export {
   encodeFloat32Arrays,
   encodeMsgpack,
 } from "./msgpack.js";
+export {
+  type DeserializeOptions,
+  deserialize,
+  type MsgpackExtension,
+  type MsgpackInput,
+  type SerializeOptions,
+  serialize,
+} from "./msgpack-core.js";
+export { msgpackCodec } from "./port-codec.js";